dsh-plugin-mobile-gateway 0.7.5 → 0.7.7

package/PROTOCOL.md

@@ -174,6 +174,8 @@ func connectAuthenticated(publicURL: URL, token: String) -> URLSessionWebSocketT
 `subscribed` 之后，服务端会紧接着发送该 Session 尚未处理的
 `question-requested` / `approval-requested`，并标记 `replay: true`。客户端必须按
 `rpcId` 去重。这保证移动端在审批产生后才打开已有 Session 时仍能显示待处理卡片。
+启用 `split-channels` 时，`subscribe` 仍由 conversation 连接发送，但上述重放帧会
+桥接到 control 连接；交互卡片不得发送到 conversation 连接。
 
 ---
 
@@ -186,9 +188,16 @@ Human-in-the-loop 分为两条独立通道：
 
 二者都是 Host waterfall 的临时请求，不属于持久化的 `session/event`，且都必须以插件为该次请求生成的 `rpcId` 通过专用响应帧回答，不能作为普通 `message` 发送。该内部实现不改变移动端帧格式。
 
+同一请求遵循“任意端先完成、所有端同步收起”的单胜方规则：Mobile 任一设备先完成时，Gateway 会结束 Host 的 WebUI 远端请求并让所有 WebUI 实例收起；任一 WebUI 先完成时，Host 会取消其余 WebUI 实例，Gateway 同时向所有 Mobile 设备广播终态。迟到响应统一视为 `not-pending`。
+
 ### 3.1 提问与回答
 
-Agent 调用 DSH 的 `ask_user_question` 工具时，插件直接接入 Host 的 `user-questions/request` waterfall，并把临时请求投影给移动端。若没有可处理该 Session 的移动连接，插件调用 `next()`，由 WebUI 或后续 Host answerer 处理。
+Agent 调用 DSH 的 `ask_user_question` 工具时，插件接入 Host 的
+`user-questions/request` waterfall，把临时请求投影给移动端，同时继续启动 WebUI
+或后续 Host answerer。任一端先给出有效答案即完成该请求；Gateway 会向所有移动端
+广播 `question-resolved`。Mobile 先完成时，Gateway 同时取消 WebUI 的对应远端请求，
+使其收起半屏弹窗；WebUI 先完成时，移动端收到终态后收起对应卡片。若 Mobile 已断开，
+则由仍在等待的 Host answerer 继续处理。
 
 #### `question-requested` — 服务端推送问题
 
@@ -292,7 +301,12 @@ Agent 调用 DSH 的 `ask_user_question` 工具时，插件直接接入 Host 的
 
 ### 3.2 操作审批
 
-当 DSH 的工具管线要求人工授权时，插件会接入一次 Host `approval/request` waterfall，并向移动端投影为 `approval-requested`。这正是 Web UI 中“等待审批”卡片对应的能力：`reason` 是面向用户的审批说明，`toolName` 标识请求操作的工具，`callId` 可用于与实时工具调用轨迹关联。
+当 DSH 的工具管线要求人工授权时，插件会接入一次 Host `approval/request`
+waterfall，并向移动端投影为 `approval-requested`，同时保留 WebUI answerer；WebUI
+与 Mobile 中任一端先提交的有效决定生效。Gateway 随后向所有移动端广播
+`approval-resolved`；若 Mobile 先完成，还会取消 WebUI 的对应远端请求以收起审批弹窗。
+`reason` 是面向用户的审批说明，`toolName` 标识请求操作的工具，`callId` 可用于与实时
+工具调用轨迹关联。
 
 #### `approval-requested` — 服务端推送待审批操作
 
@@ -956,6 +970,8 @@ WebUI 中的“任务”与“进行中的目标”分别对应 DSH 的 `todos`
 | type | 参数 | 说明 |
 |---|---|---|
 | `agent-presets` | — | preset 名册（含 `isDefault` 标记） |
+| `session-agent-preset` | `sessionId`, `requestId?` | 读取当前会话的 `agentPreset` 和 `locked` |
+| `select-agent-preset` | `sessionId`, `agentPreset`, `requestId?` | 在首次对话前修改当前会话模式，保持 session ID |
 | `defaults` | — | 读取默认 agent 预设 + 默认权限 |
 | `set-default` | `target`(agent-preset\|permission), `value` | 修改默认预设/默认权限（全局） |
 
@@ -967,6 +983,47 @@ WebUI 中的“任务”与“进行中的目标”分别对应 DSH 的 `todos`
 → { "kind": "set-default", "target": "agent-preset", "value": "minimal", "applied": true }
 ```
 
+### 当前会话模式选择
+
+`hello.capabilities` 包含 `session-agent-preset` 时，可以进入已创建的空白会话后选模式。
+上述两个新增请求走 Control 通道，成功和错误响应均携带 `sessionId` 与原始可选 `requestId`。
+
+```json
+{ "type": "session-agent-preset", "sessionId": "s1", "requestId": "get-mode-1" }
+→ { "kind": "session-agent-preset", "sessionId": "s1", "agentPreset": "standard", "locked": false, "requestId": "get-mode-1" }
+
+{ "type": "select-agent-preset", "sessionId": "s1", "agentPreset": "minimal", "requestId": "set-mode-1" }
+→ { "kind": "select-agent-preset", "sessionId": "s1", "agentPreset": "minimal", "requestId": "set-mode-1" }
+```
+
+候选项使用 `agent-presets.presets`：显示 `name`（缺失时使用 `id`），提交 `id`；带 `broken` 的项不可选。
+当前值以 `session-agent-preset.agentPreset` 为准，不能用全局 `isDefault` 或 Session header 代替。
+Host 在同一 Session 内重组 Agent 并持久化选择，不通过修改全局默认模式实现。
+
+首次消息被 gateway 接受后即锁定；已记录的用户输入或 `turn/start` 也会锁定。
+gateway 对同一 Session 的模式切换与消息提交串行处理，Host 同时保留自身的对话边界检查。
+未知/损坏的模式由 Host 拒绝，之前的模式保持；停止或完成对话不会恢复可修改状态。
+如果状态投影缺失，返回 `agent-preset/unavailable`，客户端不得把未知状态当作可修改。
+
+```json
+{ "kind": "error", "requestType": "select-agent-preset", "sessionId": "s1", "requestId": "set-mode-2", "code": "agent-preset/locked", "message": "session has already started; its agent preset is fixed" }
+```
+
+Control/旧单连接接收全局模式状态增量，不受所订阅会话过滤；只合并实际携带的字段：
+
+```json
+{ "kind": "session-agent-preset-updated", "sessionId": "s1", "agentPreset": "minimal", "seq": 12, "time": 1000 }
+{ "kind": "session-agent-preset-updated", "sessionId": "s1", "locked": true, "seq": 13, "time": 1100 }
+```
+
+模式变化后，App 应丢弃该会话的命令/技能缓存，重新查询；对话通道的 `agent-preset/selected` 事件也保留 `event.agentPreset`。
+增量没有连接基线，进入会话及重连后必须重查 `session-agent-preset`；收到锁定通知或错误后锁定控件。
+发送首条消息和切换模式期间暂时禁用操作，等待切换成功再发送消息；不要用旧查询响应覆盖后到的锁定通知。
+
+`session-create` 和不带 `sessionId` 的首条 `message` 也支持可选 `agentPreset`。
+已带 `sessionId` 的 `message` 不接受该字段；应提前调用 `select-agent-preset`。
+详细 App 状态与验收步骤见 [会话模式接入说明](docs/session-agent-preset-app-integration.md)。
+
 ---
 
 ## 11. 分支（fork）

package/README.md

@@ -28,6 +28,8 @@ DeepSeek Harness 的设备鉴权移动网关，支持会话与实时事件、排
 - Linux 服务器公网：`wss://<公网 IP>/ws/mobile`
 - 协议文档：[PROTOCOL.md](PROTOCOL.md)
 
+当前源码新增会话模式选择：App 创建空白 Session 后，可查询并修改该 Session 的 Agent preset；首次对话后锁定。通过 `session-agent-preset` 能力发现接入，详见 [App 接入说明](docs/session-agent-preset-app-integration.md)。App 界面需按此说明接入，本次源码尚未发布。
+
 ## 多网关第一阶段（当前源码）
 
 插件提供稳定 `gatewayId`、可配置 `gatewayName`、配对候选地址列表，以及可持久化的“关闭 / 临时开启 / 常驻开启”运行模式。一个 App 可以分别配对不同机器上的网关；客户端多网关管理仍需按 [App 对接说明](docs/multi-gateway-app-integration.md) 实现。本次源码尚未发布新的 npm 版本。

package/docs/dsh-0.1.6-alpha.1-compatibility-audit.md

@@ -0,0 +1,122 @@
+# DSH 0.1.6-alpha.1 协议兼容性审计
+
+核对日期：2026-09-16。
+
+## 结论
+
+当前 gateway `0.7.5` **不能直接声明完整兼容 DSH `0.1.6-alpha.1`**。确定的主要阻断是权限选择协议拆分：新版会话投影不再包含候选列表，而 gateway 的权限菜单仍依赖该列表，导致读取菜单和通过菜单切换权限均失败。
+
+核心会话、消息提交、历史分页、Assistant 独立流、普通问答和人工审批没有发现本次升级引入的接口阻断。另有默认模式的条件性语义差异、SSH 文件访问缺口、版本误报及新增事件元数据丢失。
+
+本次仅增加审计文档；没有修改生产代码、升级本机 DSH 或迁移用户会话。
+
+## 基线与验证范围
+
+- gateway：提交 `a92a039332bcfa4a1fadc55888e6b7a7e80dfd3d`，版本 `0.7.5`；开始审计时工作区干净。
+- 上游：对比官方 `dsh-v0.1.5-rc.2` 与 `dsh-v0.1.6-alpha.1` 两个 tag 的完整源码。
+- 发布包：分别下载两版 Session Controller、Workspace Controller、Settings Controller、Commands、Goal、Agent Presets、LLM 共七个包，比较生成的 `typert.host.js`；另外检查新版 Permission Presets 发布包。
+- 七组包的旧版 55 个 Remote 端点没有删除；新版增加 `workspace/unarchiveSession`。现有入参 schema 唯一差异为 `session/updateQueue` 的图片块增加可选 `offloaded: true`，没有要求旧调用增加必填参数。此数量不代表 DSH 全部端点；新 Permission Presets 包另提供 `permissionPresets/catalog`。
+- 用现有 Host Adapter 测试的真实调用，附加新版发布描述符的参数名与 schema 校验：18 次调用、14 个不同端点通过。
+- `npm test` 全部通过，包括 125 项 gateway dispatch 检查、认证配对、LAN、多网关 11 项检查，以及 Host Adapter、Session Follower、Unicode wire、setup 测试。首次运行被沙箱禁止监听端口；允许本地监听后完整运行成功。
+- 使用当前生产 `handleQuery()` 配合新版权限投影样例，复现下述权限菜单问题。
+
+验证边界：没有执行新版真实 Host 与手机全流程联调。发布描述符输入验证及旧测试通过，不代表业务行为完整兼容；权限问题恰好说明旧测试夹具可能掩盖新版差异。
+
+官方依据：[发布说明](https://github.com/deepseek-ai/deepseek-harness/releases/tag/dsh-v0.1.6-alpha.1)、[版本比较](https://github.com/deepseek-ai/deepseek-harness/compare/dsh-v0.1.5-rc.2...dsh-v0.1.6-alpha.1)。
+
+## 1. 必须适配：权限目录从会话投影拆出
+
+旧版 `projections.values.permissions`：
+
+```json
+{"options":[{"value":"workspace-write","name":"Workspace Write"}],"currentValue":"workspace-write"}
+```
+
+新版会话投影只保留：
+
+```json
+{"currentValue":"workspace-write"}
+```
+
+候选项改从新的进程级目录读取：
+
+```js
+typertGateway.invoke({
+  namespace: 'permissionPresets',
+  method: 'catalog',
+  args: {},
+})
+// 返回 { options: [{ value, name, description? }] }
+```
+
+源码在 `packages/interaction/permission-presets/src/index.ts` 注册的投影视图明确只有 `currentValue`；这不是单纯的类型重命名。新版 `auto` 由运行中的 Auto review 插件动态贡献，不属于默认权限设置中的静态候选表。`custom` 是派生的当前状态，不是可切换候选项。
+
+gateway 受影响位置：
+
+- `lib/index.mjs:1211` 的 `loadCommandOptions()` 强制要求 `permissions.options`。
+- `lib/index.mjs:1245` 的 `selectCommandOption()` 先查询上述菜单，因此写入前就失败。
+- `lib/index.mjs:1629` 的旧 `permission-options` 接口直接透传投影，新版返回值不再包含 `sessionPermissions.options`；它读取的 settings namespace 也无法补全动态 Auto 候选。
+
+生产函数复现结果：
+
+| 请求 | 当前结果 |
+|---|---|
+| `command-options`，`command=permission` | `command-options-unavailable` |
+| `command-select`，`command=permission` | 同样失败，尚未执行写入；还沿用 `requestType=command-options` |
+| `permission-options` | 成功，但 `sessionPermissions` 只剩 `currentValue` |
+| 直接 `permission`，明确传入有效名称 | 可到达原有 `/permission` 执行入口；没有被菜单前置检查阻断 |
+
+建议：Host Adapter 增加权限目录查询，将 catalog 的候选项与会话投影的 `currentValue` 合成现有移动菜单和兼容响应。保留 `/permission` 写入路径；动态目录需在使用前刷新，若缓存则处理 `permission-presets/catalog-changed`。会话 Auto 选项不能写成全局默认权限。
+
+这可以在 gateway 内适配，现有 `command-options` / `command-select` 移动消息形状可继续使用。若 App 自行解析历史中的权限投影，则也需要核对其是否依赖旧 `options` 字段。
+
+依据：[权限类型变更](https://github.com/deepseek-ai/deepseek-harness/blob/dsh-v0.1.6-alpha.1/packages/interaction/permission-presets/src/types.ts)、[权限目录与投影实现](https://github.com/deepseek-ai/deepseek-harness/blob/dsh-v0.1.6-alpha.1/packages/interaction/permission-presets/src/index.ts)。
+
+## 2. 条件性不一致与元数据缺口
+
+| 项目 | 新版变化及当前影响 | 建议 |
+|---|---|---|
+| 默认 Agent 模式 | 增加 `modeSelectionEnabled`。为 false 时，Host 对未指定 preset 的新会话使用配置默认值，忽略保存的用户默认值。gateway 的 `defaults` 仍返回 settings 中保存的 `default`；`set-default` 返回 `applied: true` 也不代表后续新会话采用该值 | 查询有效默认值时结合 `agentPresets/list` 的 `isDefault` 和 `modeSelectionEnabled`；区分已保存与实际生效。`agent-presets` 原始响应已经透传新字段 |
+| SSH 工作区 | 新版文件/进程可通过 SSH provider 操作远端。gateway `resolveSessionRoot()`、文件列表、下载及目录操作仍使用本机 `node:fs` | 启用 SSH provider 的部署不应宣称文件功能兼容；接入 Host 文件能力或明确禁用。远端路径本机不存在会失败，同名本机路径存在时可能访问错误目录。普通本地工作区不受此项影响 |
+| 宿主版本误报 | `lib/dsh-host-adapter.mjs:16` 将 `DSH_VERSION` 写死为 `0.1.5-rc.2`；`host.describe` 和 `hello` 均使用该值 | 改为真实宿主版本或明确的兼容目标字段。这不是运行时版本拒绝逻辑，但会误导诊断/版本判断 |
+| `image/offload` | 新增持久事件，`data.targets` 包含消息 `seq` 和 `imageIndexes`。gateway 接受其真实序号，历史保留原始数据；实时 `buildWireEvent()` 的默认分支只发事件类型，丢弃 targets | 基础聊天不因未知类型直接中断，但实时 offload 语义缺失；需要展示模型实际保留的图片上下文时补齐映射 |
+| Auto review 拒绝原因 | `tool/result.data.error` 增加可选 `reason`，位于模型消息之外。实时映射只保留 `isError` 和模型内容 preview，丢失结构化错误名、代码和原始原因 | 保留必要的 error 元信息。历史仍保留这些数据，实时展示存在缺口 |
+
+Auto review 使用 `tools/pre-execute` 的自动决策入口。普通 `approval/request` / `user-questions/request` 的签名及回答形状没有改变，不能据此把所有审批流判定为失效。
+
+依据：[默认模式选择策略](https://github.com/deepseek-ai/deepseek-harness/blob/dsh-v0.1.6-alpha.1/packages/preset/agent-presets/src/index.ts)、[SSH 文件系统提供方](https://github.com/deepseek-ai/deepseek-harness/blob/dsh-v0.1.6-alpha.1/packages/ssh/fs-ssh/README.zh.md)、[image/offload 定义](https://github.com/deepseek-ai/deepseek-harness/blob/dsh-v0.1.6-alpha.1/packages/compaction/compaction-image-offload/src/projection.ts)、[Session 工具错误定义](https://github.com/deepseek-ai/deepseek-harness/blob/dsh-v0.1.6-alpha.1/packages/core/session/src/types.ts)、[Auto review 实现](https://github.com/deepseek-ai/deepseek-harness/blob/dsh-v0.1.6-alpha.1/packages/experimental/auto-review/src/index.ts)。
+
+## 3. 保持兼容或仅增加能力的部分
+
+| 范围 | 核对结果 |
+|---|---|
+| 会话格式 | `SESSION_FORMAT_VERSION` 仍为 3。本次没有 rc.2 那次跨格式的历史游标迁移；不要把 DSH 软件版本、Session 格式和移动握手值混为一谈 |
+| 会话读取和控制 | `session/list` 仍使用 `{ _request: {} }`；`follow/page/control` 入参保持不变。Assistant 的快照及 `start/chunk/end` 协定保持不变 |
+| 消息、命令、队列 | prompt 原有文字和图片结构仍有效；命令仍使用 `submittedAttachments`；队列图片块新增可选 `offloaded`，现有文字编辑请求不需修改 |
+| Session fork | 参数不变，切点改为所选边界 `seq + 1`，不再继续带入下次 `turn/start` 前的后续输入/设置。这是上游行为修复，gateway 原有 atSeq 转发无需改协议 |
+| 工作区归档 | 原有 archive 和归档集合推送保持；增加 `workspace/unarchiveSession({ request: { sessionId } })`。gateway 尚未提供恢复归档请求，但从 Web 恢复后，可通过已有 workspace stream 同步归档集合 |
+| Skill / 命令目录 | Skill 增加可选 `path`，CommandDescriptor 增加可选 `definitionId`；当前按名字执行不受影响，移动组合菜单没有保留这两个新元信息 |
+| 插件生命周期 | `agent/session-start` 移除，`agent/created` 改为等待完成的异步串行初始化；gateway 不监听这两个事件，不需要修改该 hook |
+| 同步 Session 历史 API | `snapshotEvents/eventAt/ownEvents` 是弃用，非本版本全部删除。gateway 通过 Remote follow/page 读取，不直接依赖这些同步 API |
+| Host 服务及 Web UI | `typertGateway.invoke/stream`、`agentDefaultModel`、`webServer.register/registerUpgrade` 及当前 sidebar/footer、shell/overlay 集成入口未发现阻断变化 |
+
+依据：[Session Remote 类型](https://github.com/deepseek-ai/deepseek-harness/blob/dsh-v0.1.6-alpha.1/packages/api/session-controller/src/types.ts)、[fork 实现](https://github.com/deepseek-ai/deepseek-harness/blob/dsh-v0.1.6-alpha.1/packages/api/session-controller/src/commands.ts)、[Workspace Controller](https://github.com/deepseek-ai/deepseek-harness/blob/dsh-v0.1.6-alpha.1/packages/api/workspace-controller/src/index.ts)、[Agent 生命周期](https://github.com/deepseek-ai/deepseek-harness/blob/dsh-v0.1.6-alpha.1/packages/core/agent/src/runtime-types.ts)。
+
+## 4. 模型协议和部署配置变化
+
+DeepSeek 默认由 Chat Completions 改为 Messages，并增加 Files API 图片复用。这发生在 Host 到模型服务之间；gateway 使用 Host 的统一 Session/LLM 数据模型，不需要把移动 WebSocket 改成 Anthropic Messages。
+
+显式配置旧官方根地址的部署，需要移除覆盖或使用 `https://api.deepseek.com/anthropic`；自定义 API 地址会保留，因此要核对其与所选协议是否匹配。否则可能出现手机正常连接、模型请求失败的情况。本次没有读取用户凭据或验证实际模型服务配置。
+
+PTC 包/服务统一改为 `ptc-runtime`、工作流执行器改为 `workflow-ptc`、E2B 移除、Ralph 默认关闭，以及 Sandbox/Shell 异步接口变化，均需使用相关自定义插件或配置的部署另行适配。当前 gateway 没有这些直接依赖，bundle patch 也没有引用这些旧名称。终端、MCP resources、Browser/Computer Use 属于新增能力，不能据此认定当前移动端已经支持。
+
+依据：[DeepSeek 协议默认配置](https://github.com/deepseek-ai/deepseek-harness/blob/dsh-v0.1.6-alpha.1/packages/llm/llm-deepseek/src/config.ts)、[官方发布说明](https://github.com/deepseek-ai/deepseek-harness/releases/tag/dsh-v0.1.6-alpha.1)。
+
+## 建议顺序
+
+1. 优先修复权限目录适配，覆盖新版只有 `currentValue` 的投影、动态 Auto、派生 custom、菜单查询与选择及兼容接口。
+2. 修正宿主版本信息和默认 Agent 模式的有效值语义。
+3. 本地工作区完成真实 Host 与 App 的消息、生成中重连、历史分页、fork、权限切换、问答/审批、文件下载及归档同步联调。
+4. 单独决定是否接入恢复归档、SSH 文件访问、image/offload 展示和 Auto review 错误详情。
+
+临时证据目录：`/private/tmp/dsh-alpha1-audit/`，含双版本源码、npm 包、`check-contract.mjs`、`schema-deltas.json`、`reproduce-permissions.mjs`、`permission-reproduction.json` 和完整测试日志。临时探针没有改动仓库生产实现或原有测试。

package/docs/session-agent-preset-app-integration.md

@@ -0,0 +1,93 @@
+# App 会话运行模式接入说明
+
+## 实现范围
+
+gateway 已增加同一 Session 内的 Agent 模式查询、切换、锁定与通知。App 界面尚未修改；本次源码没有发布 npm，也没有升级本机 DSH。
+
+用户流程：创建空白会话 → 进入会话页 → 选择已有模式，可重复修改 → 发送第一条消息 → 模式固定，后续完成、停止、重连均不可再次修改。
+
+这里的模式是 Agent preset，例如 `standard`、`minimal`，与模型选择、权限模式及 gateway 的常驻/临时运行模式相互独立。
+
+## 接入顺序
+
+1. 检查 `hello.capabilities` 是否包含 `session-agent-preset`。没有则不提供当前会话切换入口。
+2. 用现有 `session-create` 创建会话，收到 `session-created` 后以其 `sessionId` 进入会话页。
+3. 在 Control 通道查询 `agent-presets` 和 `session-agent-preset`；查询未完成期间禁止选择。
+4. 显示当前模式的名称；只有 `locked: false` 才允许打开选择器。名册使用 `presets`，显示 `name/description`，提交 `id`，有 `broken` 的项禁用并显示原因。
+5. 选择后发送 `select-agent-preset`，携带唯一 `requestId`。保存期间禁止再次切换和发送消息；以成功响应的 `agentPreset` 更新当前值。失败保留原值并展示错误。
+6. 成功切换后重新读取该 Session 的 `commands` 和 `skills`，因为模式决定工具、命令及技能集合。
+7. 点击发送第一条消息立即在 App 暂时禁用模式选择，收到 `sent` 后保持锁定。若提交报错，重新查询状态再决定是否解锁；连接断开或请求超时也必须先重新查询。
+8. 每次进入会话或重连时重查当前模式状态，不能依赖上次连接的本地可编辑标记。
+
+`agent-presets` 的 `modeSelectionEnabled: false` 表示 Host 隐藏模式选择 UI 的设置，App 可遵循同一设置隐藏入口；旧 Host 没有该字段时默认显示。它不改变 `locked` 的含义。全局 `isDefault` 只用于未指定模式时的默认提示，不能覆盖已有会话当前值。
+
+## 请求与响应
+
+```json
+{"type":"session-create","requestId":"create-1","workspaceId":"w1","agentPreset":"standard"}
+{"kind":"session-created","requestId":"create-1","sessionId":"s1","agentPreset":"standard"}
+
+{"type":"agent-presets"}
+{"kind":"agent-presets","presets":[{"id":"standard","name":"标准模式","isDefault":true},{"id":"minimal","name":"精简模式","isDefault":false}],"modeSelectionEnabled":true}
+
+{"type":"session-agent-preset","sessionId":"s1","requestId":"state-1"}
+{"kind":"session-agent-preset","sessionId":"s1","requestId":"state-1","agentPreset":"standard","locked":false}
+
+{"type":"select-agent-preset","sessionId":"s1","agentPreset":"minimal","requestId":"select-1"}
+{"kind":"select-agent-preset","sessionId":"s1","requestId":"select-1","agentPreset":"minimal"}
+```
+
+创建时的 `agentPreset` 可省略，沿用 Host 默认值。选择成功响应不带 `locked: false`，避免把并发到达的开始对话通知重新解锁。
+
+如果沿用“首条消息自动创建会话”的流程，只能在不带 `sessionId` 的 `message` 上附带 `agentPreset`；已有 Session 的模式修改必须使用独立选择接口。
+
+## 多端更新及缓存
+
+Control 通道（或旧版单连接）会收到：
+
+```json
+{"kind":"session-agent-preset-updated","sessionId":"s1","agentPreset":"minimal","seq":12,"time":1000}
+{"kind":"session-agent-preset-updated","sessionId":"s1","locked":true,"seq":13,"time":1100}
+```
+
+- 第一种表示模式已提交，包括从 WebUI 切换产生的事件；仅更新模式，清除命令/技能缓存。
+- 第二种表示已开始对话，仅更新锁定状态。未携带的字段保持原值。
+- 更新按 `gatewayId + sessionId` 定位；这些控制增量不受对话订阅过滤，不要错误应用到当前显示的其他会话。
+- `seq` 是该通知对应的持久事件序号，不是独立的控制通知连续序列。
+- 同一页面只保留最新 `requestId` 的查询/选择响应；离开页面、切换 gateway 或 session 后忽略旧响应。查询发出后若收到锁定通知，不可被该查询的迟到 `locked: false` 覆盖。
+- 通知不重放连接基线。重连查询负责恢复当前值和锁定状态，历史 `projections.values.agentPreset` 也可更新模式。
+- Session header 的 preset 是创建事实；用户在空白阶段切换后，当前值来自投影，不能只读 header。
+
+## 错误处理
+
+| code | App 行为 |
+|---|---|
+| `agent-preset/locked` | 锁定模式入口，提示对话开始后不可修改 |
+| `agent-preset/not-found` | 保留原模式，刷新已有模式列表 |
+| `agent-preset/invalid` | 保留原模式，展示 Host 返回的损坏或不可用原因 |
+| `agent-preset/unavailable` | 状态未知，保持禁用；不可假定为空白会话 |
+| `session/not-found` | 刷新会话列表并退出无效会话 |
+| `bad-request` | 请求缺少有效的 sessionId 或 agentPreset，应修正客户端参数 |
+| 其他 Host/网络错误 | 保留原模式，重查状态；不自动重复有副作用的写入 |
+
+新增查询和选择接口的成功及 Host 错误响应均保留有效 `sessionId` 和传入的字符串 `requestId`。本地参数错误至少保留 `requestType/requestId`。
+
+## Host 对接与锁定规则
+
+- 切换调用官方 `agentPresets/select`，参数为 `{ agentId: sessionId, agentPreset }`；它重组 Agent、写入 `agent-preset/selected`，不更换 ID、不修改全局默认值。
+- 查询读取 `session/follow` 首帧的当前 preset 和 `sessionListMetadata`，不以“历史 events 数组为空”判断可编辑，因为历史会分页，空白会话也有初始化事件。
+- 历史含对话轮次或用户输入即锁定。gateway 还覆盖 prompt 已受理但尚未写入轮次事件的间隙。
+- 同一 gateway 内，模式选择与消息提交按 Session 串行，Control/Conversation 两个 socket 的竞争不会让第一条消息越过尚未完成的模式切换。
+- Host 自身仍会检查会话轮次边界。WebUI 等绕过 gateway 的并发操作由 Host 自身负责；本次没有修改 Host 的并发实现。
+
+## 验收
+
+- 新建 → 查询标准模式 → 改成精简模式 → 改回标准模式，全程 session ID 不变。
+- 发送第一条消息后，UI 立即锁定；绕过 UI 直接调用选择接口也返回 `agent-preset/locked`。
+- 轮次完成、停止、App 重连、gateway 重启后仍锁定。
+- 未知/损坏模式切换失败，原模式与会话保留；之后仍可选择有效模式。
+- 保存模式期间发送消息不会抢先执行；两个设备并发操作能按响应和通知收敛。
+- WebUI 切换模式后，App 当前模式、命令和技能缓存同步更新；WebUI 开始对话后 App 锁定。
+- 切换到另一个 Session 时，旧 Session 的迟到响应不能修改新页面。
+
+自动测试覆盖 Adapter 真实参数、消息/选择排序、历史锁定、输入校验、错误透传和真实本地 WebSocket 的模式查询、切换通知、锁定、双通道分流。未执行新版真实 DSH 与手机联调。

package/lib/dsh-host-adapter.mjs

@@ -133,6 +133,31 @@ export function createDshHostAdapter(typertGateway) {
     'session/modelCatalog',
   )
 
+  // Control and conversation sockets share this adapter. Admit a prompt only
+  // after an earlier preset switch finishes, and re-check later switches.
+  const sessionOperations = new Map()
+  const admittedPrompts = new Set()
+  const serializeSession = (sessionId, operation) => {
+    const task = (sessionOperations.get(sessionId) ?? Promise.resolve()).then(operation)
+    const guard = task.catch(() => {})
+    sessionOperations.set(sessionId, guard)
+    return task.finally(() => {
+      if (sessionOperations.get(sessionId) === guard) sessionOperations.delete(sessionId)
+    })
+  }
+  const sessionPreset = async (sessionId, signal) => {
+    const snapshot = await sessionSnapshot({ address: { kind: 'session', sessionId }, maxMessages: 1 }, signal)
+    const values = snapshot.projections.values
+    const metadata = values?.sessionListMetadata
+    if (typeof values?.agentPreset !== 'string' || !metadata || typeof metadata.blank !== 'boolean'
+      || !(metadata.lastPromptAt === null || Number.isFinite(metadata.lastPromptAt))) {
+      throw Object.assign(new Error('session preset state is unavailable'), { code: 'agent-preset/unavailable' })
+    }
+    const durableLock = !metadata.blank || metadata.lastPromptAt !== null
+    if (durableLock) admittedPrompts.delete(sessionId)
+    return { sessionId, agentPreset: values.agentPreset, locked: durableLock || admittedPrompts.has(sessionId) }
+  }
+
   const commands = {
     list: (sessionId, signal) => invoke('commands', 'list', { agentId: sessionId }, signal),
     // DSH 0.1.5-rc.2 accepts `submittedAttachments`. The parsed
@@ -177,10 +202,18 @@ export function createDshHostAdapter(typertGateway) {
       list: (payload = {}, signal) => invoke('session', 'list', sessionListArgs(payload), signal),
       search: (payload, signal) => invoke('session', 'search', requestArgs(payload), signal),
       create: (payload, signal) => invoke('session', 'create', requestArgs(payload), signal),
-      prompt: (payload, signal) => invoke('session', 'prompt', requestArgs({
-        requestId: crypto.randomUUID(),
-        ...payload,
-      }), signal),
+      prompt: (payload, signal) => serializeSession(payload.sessionId, async () => {
+        // Accepted input may not have reached turn/start yet. Keep that gap
+        // locked; the persistent event or a subsequent read retires the marker.
+        const alreadyAdmitted = admittedPrompts.has(payload.sessionId)
+        admittedPrompts.add(payload.sessionId)
+        try {
+          return await invoke('session', 'prompt', requestArgs({ requestId: crypto.randomUUID(), ...payload }), signal)
+        } catch (error) {
+          if (!alreadyAdmitted) admittedPrompts.delete(payload.sessionId)
+          throw error
+        }
+      }),
       attachment: (payload, signal) => invoke('session', 'attachment', requestArgs(payload), signal),
       fork: (payload, signal) => invoke('session', 'fork', requestArgs(payload), signal),
       cancel: (payload, signal) => invoke('session', 'cancel', requestArgs(payload), signal),
@@ -225,6 +258,20 @@ export function createDshHostAdapter(typertGateway) {
     },
     agentPresets: {
       list: (_payload = {}, signal) => invoke('agentPresets', 'list', {}, signal),
+      session: (payload, signal) => serializeSession(payload.sessionId, () => sessionPreset(payload.sessionId, signal)),
+      select: (payload, signal) => serializeSession(payload.sessionId, async () => {
+        const state = await sessionPreset(payload.sessionId, signal)
+        if (state.locked) {
+          throw Object.assign(new Error('session has already started; its agent preset is fixed'), { code: 'agent-preset/locked' })
+        }
+        // Host validates the live catalog, mounts the composition, checks its
+        // own turn boundary and persists agent-preset/selected on this ID.
+        const selected = await invoke('agentPresets', 'select', {
+          agentId: payload.sessionId, agentPreset: payload.agentPreset,
+        }, signal)
+        if (typeof selected !== 'string' || !selected) throw new Error('agentPresets/select returned an invalid preset')
+        return { sessionId: payload.sessionId, agentPreset: selected }
+      }),
     },
     llm: {
       async models(_payload = {}, signal) {
@@ -269,6 +316,9 @@ export function createDshHostAdapter(typertGateway) {
       describe: (_payload = {}, signal) => describeHost(signal),
     },
     describeHost,
+    observeSessionEvent(sessionId, event) {
+      if (event.type === 'turn/start') admittedPrompts.delete(sessionId)
+    },
     openSessionStream(sessionId, signal) {
       return typertGateway.stream({
         namespace: 'session', method: 'follow',

package/lib/index.mjs

@@ -314,6 +314,8 @@ function buildWireEvent(session, event) {
           ...(d.source ? { source: d.source } : {}),
         },
       })
+    case 'agent-preset/selected':
+      return Object.assign(base, { event: { type: event.type, agentPreset: d.agentPreset } })
     case 'tool/call':
       return Object.assign(base, {
         event: { type: 'tool/call', turn: d.turn, step: d.step, callId: d.callId, name: d.name, arguments: d.arguments },
@@ -496,6 +498,12 @@ async function admitCommand(host, msg) {
 // Handle one mobile -> agent message through the official host API. Returns
 // the wire frame to send back, or null when nothing should be sent.
 async function admitMessage(api, msg) {
+  const preset = parseAgentPreset(msg, 'message')
+  if (preset.error) return preset.error
+  if (preset.value !== undefined && typeof msg.sessionId === 'string' && msg.sessionId.trim()) {
+    return { kind: 'error', code: 'bad-request', requestType: 'message',
+      message: 'use select-agent-preset before sending a message to an existing session' }
+  }
   const text = typeof msg.text === 'string' ? msg.text.trim() : ''
   const parsedImages = parseWireImages(msg.images, 'message')
   if (parsedImages.error) return parsedImages.error
@@ -511,6 +519,7 @@ async function admitMessage(api, msg) {
       // New session: optionally place it in a workspace (at most one of
       // workspaceId / cwd, per the host create contract; workspaceId wins).
       const createPayload = {}
+      if (preset.value !== undefined) createPayload.agentPreset = preset.value
       if (typeof msg.workspaceId === 'string' && msg.workspaceId.trim() !== '') {
         createPayload.workspaceId = msg.workspaceId.trim()
       }
@@ -1307,13 +1316,36 @@ async function selectCommandOption(api, host, command, sessionId, optionId) {
   return { kind: 'error', code: 'bad-request', message: `command is not selectable: ${command}`, requestType: 'command-select', sessionId }
 }
 
+function parseAgentPreset(msg, requestType, required = false) {
+  if (msg.agentPreset === undefined && !required) return {}
+  if (typeof msg.agentPreset !== 'string' || !msg.agentPreset.trim()) {
+    return { error: { kind: 'error', code: 'bad-request', requestType,
+      message: 'agentPreset must be a non-empty preset ID' } }
+  }
+  return { value: msg.agentPreset.trim() }
+}
+
 // Dispatch one mobile query frame; returns the wire frame to send back.
 async function handleQuery(api, host, agentDefaultModel, msg) {
+  if (msg.type === 'session-agent-preset' || msg.type === 'select-agent-preset') {
+    const session = requireSessionId(msg)
+    const preset = parseAgentPreset(msg, msg.type, msg.type === 'select-agent-preset')
+    const requestId = typeof msg.requestId === 'string' ? { requestId: msg.requestId } : {}
+    if (session.error || preset.error) return { ...(session.error || preset.error), ...requestId }
+    const method = msg.type === 'session-agent-preset' ? 'session' : 'select'
+    const frame = await proxyQuery(api, msg.type, api.agentPresets[method].bind(api.agentPresets), {
+      sessionId: session.value, ...(preset.value === undefined ? {} : { agentPreset: preset.value }),
+    })
+    return { ...frame, sessionId: session.value, ...requestId }
+  }
   if (msg.type === 'session-create') {
     if (typeof msg.requestId !== 'string' || !msg.requestId.trim()) {
       return { kind: 'error', code: 'bad-request', message: 'session-create requires a requestId', requestType: 'session-create' }
     }
     const payload = {}
+    const preset = parseAgentPreset(msg, msg.type)
+    if (preset.error) return { ...preset.error, requestId: msg.requestId }
+    if (preset.value !== undefined) payload.agentPreset = preset.value
     if (typeof msg.workspaceId === 'string' && msg.workspaceId.trim()) {
       payload.workspaceId = msg.workspaceId.trim()
     } else if (typeof msg.cwd === 'string' && msg.cwd.trim()) {
@@ -2213,20 +2245,43 @@ const plugin = {
     }
 
     const replayPendingInteractions = (ws, trigger) => {
-      if (ws.mobileChannel === 'conversation') return { questionCount: 0, approvalCount: 0 }
+      // In split-channel mode `subscribe` belongs to the conversation socket,
+      // while interaction frames belong to the control socket. Bridge a
+      // conversation subscription to every live control/legacy socket so
+      // reopening a Session restores its still-pending cards. Reducers dedupe
+      // by rpcId, so replaying to another trusted device is harmless and keeps
+      // all active clients in sync.
+      // The companion control socket already receives a full replay when it
+      // connects, so a bare conversation connect must not duplicate it again.
+      if (ws.mobileChannel === 'conversation' && trigger !== 'subscribe') {
+        return { questionCount: 0, approvalCount: 0 }
+      }
+      const recipients = ws.mobileChannel === 'conversation'
+        ? [...clients].filter((client) => client.readyState === 1 && client.mobileChannel !== 'conversation')
+        : [ws]
+      if (recipients.length === 0) return { questionCount: 0, approvalCount: 0 }
+      const sessionId = ws.filterSessionId
       let questionCount = 0
       let approvalCount = 0
       for (const pending of pendingQuestions.values()) {
-        if (ws.filterSessionId && ws.filterSessionId !== pending.sessionId) continue
-        ws.send(stringifyWireFrame(questionFrameFor(pending.rpcId, pending, true)))
+        if (sessionId && sessionId !== pending.sessionId) continue
+        const wire = stringifyWireFrame(questionFrameFor(pending.rpcId, pending, true))
+        for (const recipient of recipients) {
+          if (recipient.filterSessionId && recipient.filterSessionId !== pending.sessionId) continue
+          recipient.send(wire)
+        }
         questionCount += 1
       }
       for (const pending of pendingApprovals.values()) {
-        if (ws.filterSessionId && ws.filterSessionId !== pending.sessionId) continue
-        ws.send(stringifyWireFrame(approvalFrameFor(pending.rpcId, pending, true)))
+        if (sessionId && sessionId !== pending.sessionId) continue
+        const wire = stringifyWireFrame(approvalFrameFor(pending.rpcId, pending, true))
+        for (const recipient of recipients) {
+          if (recipient.filterSessionId && recipient.filterSessionId !== pending.sessionId) continue
+          recipient.send(wire)
+        }
         approvalCount += 1
       }
-      log(`interaction replay: trigger=${trigger} filtered=${Boolean(ws.filterSessionId)} questions=${questionCount} approvals=${approvalCount}`)
+      log(`interaction replay: trigger=${trigger} channel=${ws.mobileChannel} filtered=${Boolean(sessionId)} recipients=${recipients.length} questions=${questionCount} approvals=${approvalCount}`)
       return { questionCount, approvalCount }
     }
 
@@ -2236,15 +2291,24 @@ const plugin = {
       && (!client.filterSessionId || client.filterSessionId === sessionId)
     ))
 
-    const completeQuestion = (pending, action, answer, cancellationCode = 'ASK_CANCELLED') => {
+    const abortDownstreamInteraction = (pending, kind) => {
+      if (pending.downstreamAbort.signal.aborted) return
+      // The Host API gateway fans this abort out to every WebUI delivery of
+      // the same Remote event. Its existing cancel handling removes each
+      // pending BottomSheet; Mobile peers receive the resolved frame below.
+      pending.downstreamAbort.abort(new Error(`${kind} completed outside WebUI`))
+    }
+
+    const completeQuestion = (pending, action, answer, cancellationCode = 'ASK_CANCELLED', cancellationError, source = 'mobile') => {
       if (pendingQuestions.get(pending.rpcId) !== pending) return false
       pendingQuestions.delete(pending.rpcId)
       pending.cleanup()
+      if (source !== 'downstream') abortDownstreamInteraction(pending, 'question')
       if (action === 'answer') pending.resolve(answer)
       else {
-        const error = new Error('question cancelled by mobile user')
-        error.name = 'UserQuestionError'
-        error.code = cancellationCode
+        const error = cancellationError ?? new Error('question cancelled by mobile user')
+        if (!error.name || error.name === 'Error') error.name = 'UserQuestionError'
+        if (!error.code) error.code = cancellationCode
         pending.reject(error)
       }
       broadcastInteractionFrame({
@@ -2283,10 +2347,11 @@ const plugin = {
       return { value: { answers: normalized } }
     }
 
-    const completeApproval = (pending, outcome) => {
+    const completeApproval = (pending, outcome, source = 'mobile') => {
       if (pendingApprovals.get(pending.rpcId) !== pending) return false
       pendingApprovals.delete(pending.rpcId)
       pending.cleanup()
+      if (source !== 'downstream') abortDownstreamInteraction(pending, 'approval')
       pending.resolve(outcome)
       broadcastInteractionFrame({
         kind: 'approval-resolved',
@@ -2298,18 +2363,80 @@ const plugin = {
       return true
     }
 
+    const startDownstreamQuestion = (pending) => {
+      let downstream
+      try {
+        downstream = pending.next()
+      } catch (error) {
+        pending.downstream = { kind: 'rejected', error }
+        return
+      }
+      pending.downstream = { kind: 'pending' }
+      Promise.resolve(downstream).then((answer) => {
+        if (pendingQuestions.get(pending.rpcId) !== pending) return
+        if (answer && Array.isArray(answer.answers)) {
+          completeQuestion(pending, 'answer', answer, undefined, undefined, 'downstream')
+          log(`question resolved by downstream answerer: rpcId=${pending.rpcId} session=${pending.sessionId}`)
+        } else {
+          // A downstream answerer may report that no WebUI currently owns the
+          // request. Keep Mobile active; the value is used only if every Mobile
+          // client later disconnects.
+          pending.downstream = { kind: 'unavailable', value: answer }
+          if (!hasInteractionClient(pending.sessionId)) fallbackQuestion(pending)
+        }
+      }, (error) => {
+        if (pendingQuestions.get(pending.rpcId) !== pending) return
+        if (error?.code === 'ASK_CANCELLED' || error?.code === 'ASK_ABORTED') {
+          completeQuestion(pending, 'cancel', undefined, error.code, error, 'downstream')
+          log(`question cancelled by downstream answerer: rpcId=${pending.rpcId} session=${pending.sessionId}`)
+        } else {
+          pending.downstream = { kind: 'rejected', error }
+          if (!hasInteractionClient(pending.sessionId)) fallbackQuestion(pending)
+        }
+      })
+    }
+
+    const startDownstreamApproval = (pending) => {
+      let downstream
+      try {
+        downstream = pending.next()
+      } catch (error) {
+        pending.downstream = { kind: 'rejected', error }
+        return
+      }
+      pending.downstream = { kind: 'pending' }
+      Promise.resolve(downstream).then((outcome) => {
+        if (pendingApprovals.get(pending.rpcId) !== pending) return
+        if (outcome === 'allowed-once' || outcome === 'rejected') {
+          completeApproval(pending, outcome, 'downstream')
+          log(`approval resolved by downstream answerer: rpcId=${pending.rpcId} session=${pending.sessionId} outcome=${outcome}`)
+        } else {
+          pending.downstream = { kind: 'unavailable', value: outcome }
+          if (!hasInteractionClient(pending.sessionId)) fallbackApproval(pending)
+        }
+      }, (error) => {
+        if (pendingApprovals.get(pending.rpcId) !== pending) return
+        pending.downstream = { kind: 'rejected', error }
+        if (!hasInteractionClient(pending.sessionId)) fallbackApproval(pending)
+      })
+    }
+
     const fallbackQuestion = (pending) => {
       if (pendingQuestions.get(pending.rpcId) !== pending) return
+      if (pending.downstream?.kind === 'pending') return
       pendingQuestions.delete(pending.rpcId)
       pending.cleanup()
-      Promise.resolve().then(pending.next).then(pending.resolve, pending.reject)
+      if (pending.downstream?.kind === 'rejected') pending.reject(pending.downstream.error)
+      else pending.resolve(pending.downstream?.value)
     }
 
     const fallbackApproval = (pending) => {
       if (pendingApprovals.get(pending.rpcId) !== pending) return
+      if (pending.downstream?.kind === 'pending') return
       pendingApprovals.delete(pending.rpcId)
       pending.cleanup()
-      Promise.resolve().then(pending.next).then(pending.resolve, pending.reject)
+      if (pending.downstream?.kind === 'rejected') pending.reject(pending.downstream.error)
+      else pending.resolve(pending.downstream?.value)
     }
 
     const releaseUnclaimedInteractions = () => {
@@ -2665,7 +2792,8 @@ const plugin = {
                        msg.type === 'workspace-create' || msg.type === 'session-create' || msg.type === 'models' || msg.type === 'commands' || msg.type === 'command-execute' ||
                        msg.type === 'command-options' || msg.type === 'command-select' || msg.type === 'select-model' ||
                        msg.type === 'permission-options' || msg.type === 'permission' || msg.type === 'context-usage' ||
-                       msg.type === 'agent-presets' || msg.type === 'defaults' || msg.type === 'set-default' ||
+                       msg.type === 'agent-presets' || msg.type === 'session-agent-preset' || msg.type === 'select-agent-preset' ||
+                       msg.type === 'defaults' || msg.type === 'set-default' ||
                        msg.type === 'session-stats' || msg.type === 'default-model' ||
                        msg.type === 'save-default-model' || msg.type === 'fork' || msg.type === 'session-cancel' || msg.type === 'queue-update' ||
                        msg.type === 'session-archive' || msg.type === 'session-rename' || msg.type === 'providers' ||
@@ -2712,6 +2840,7 @@ const plugin = {
               'projection-baseline',
               'images',
               'session-create',
+              'session-agent-preset',
               'commands',
               'tasks',
               'goals',
@@ -2789,6 +2918,7 @@ const plugin = {
     }
 
     const disposeEvents = ctx.on('session/event', (session, event) => {
+      api.observeSessionEvent(String(session.id), event)
       if (clients.size === 0) return
       const wire = buildWireEvent(session, event)
       if (!wire) return
@@ -2802,6 +2932,12 @@ const plugin = {
           ...(event.data.source ? { source: event.data.source } : {}),
         })
       }
+      if (event.type === 'agent-preset/selected' || event.type === 'turn/start') {
+        broadcastSessionMetadataFrame({
+          kind: 'session-agent-preset-updated', sessionId: String(session.id), seq: event.seq, time: event.time,
+          ...(event.type === 'turn/start' ? { locked: true } : { agentPreset: event.data.agentPreset }),
+        })
+      }
       const payload = stringifyWireFrame(wire)
       for (const client of clients) {
         if (client.mobileChannel === 'control' || client.sessionFollowerActive) continue
@@ -2816,22 +2952,29 @@ const plugin = {
       if (!sessionId || !Array.isArray(request.questions) || !hasInteractionClient(sessionId)) return next()
       const rpcId = crypto.randomUUID()
       return new Promise((resolve, reject) => {
+        const requestSignal = request.signal
+        const downstreamAbort = new AbortController()
+        request.signal = requestSignal
+          ? AbortSignal.any([requestSignal, downstreamAbort.signal])
+          : downstreamAbort.signal
         const onAbort = () => {
           const pending = pendingQuestions.get(rpcId)
           if (pending) completeQuestion(pending, 'cancel', undefined, 'ASK_ABORTED')
         }
-        request.signal?.addEventListener('abort', onAbort, { once: true })
+        requestSignal?.addEventListener('abort', onAbort, { once: true })
         const pending = {
           rpcId,
           sessionId,
           questions: request.questions,
           next,
+          downstreamAbort,
           resolve,
           reject,
-          cleanup: () => request.signal?.removeEventListener('abort', onAbort),
+          cleanup: () => requestSignal?.removeEventListener('abort', onAbort),
         }
         pendingQuestions.set(rpcId, pending)
         broadcastInteractionFrame(questionFrameFor(rpcId, pending))
+        startDownstreamQuestion(pending)
         log(`question requested: rpcId=${rpcId} session=${sessionId} questions=${request.questions.length}`)
       })
     }, { prepend: true })
@@ -2842,11 +2985,16 @@ const plugin = {
       const rpcId = crypto.randomUUID()
       const approvalId = crypto.randomUUID()
       return new Promise((resolve, reject) => {
+        const requestSignal = request.signal
+        const downstreamAbort = new AbortController()
+        request.signal = requestSignal
+          ? AbortSignal.any([requestSignal, downstreamAbort.signal])
+          : downstreamAbort.signal
         const onAbort = () => {
           const pending = pendingApprovals.get(rpcId)
           if (pending) completeApproval(pending, 'cancelled')
         }
-        request.signal?.addEventListener('abort', onAbort, { once: true })
+        requestSignal?.addEventListener('abort', onAbort, { once: true })
         const pending = {
           rpcId,
           sessionId,
@@ -2855,12 +3003,14 @@ const plugin = {
           ...(request.callId !== undefined ? { callId: request.callId } : {}),
           ...(request.reason !== undefined ? { reason: request.reason } : {}),
           next,
+          downstreamAbort,
           resolve,
           reject,
-          cleanup: () => request.signal?.removeEventListener('abort', onAbort),
+          cleanup: () => requestSignal?.removeEventListener('abort', onAbort),
         }
         pendingApprovals.set(rpcId, pending)
         broadcastInteractionFrame(approvalFrameFor(rpcId, pending))
+        startDownstreamApproval(pending)
         log(`approval requested: rpcId=${rpcId} approvalId=${approvalId} session=${sessionId} tool=${request.toolName}`)
       })
     }, { prepend: true })

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-plugin-mobile-gateway",
-  "version": "0.7.5",
-  "description": "Mobile gateway for dsh 0.1.5-rc.1/2 with smaller opening history snapshots, accurate query error reporting, Unicode-safe wire frames, and preserved user message IDs",
+  "version": "0.7.7",
+  "description": "Mobile gateway for dsh 0.1.5-rc.1/2 with per-session Agent preset selection before the first conversation, automatic preset locking after conversation starts, and live preset updates",
   "main": "lib/index.mjs",
   "files": [
     "bin",
@@ -26,7 +26,7 @@
   },
   "bin": "bin/setup-ip.mjs",
   "scripts": {
-    "test": "node test/wire-json.test.mjs && node test/setup-ip.test.mjs && node test/host-adapter.test.mjs && node test/session-follower.test.mjs && node test/gateway.test.mjs && node test/auth.test.mjs && node test/lan.test.mjs && node test/multi-gateway.test.mjs"
+    "test": "node test/wire-json.test.mjs && node test/setup-ip.test.mjs && node test/host-adapter.test.mjs && node test/session-preset.test.mjs && node test/session-follower.test.mjs && node test/gateway.test.mjs && node test/auth.test.mjs && node test/lan.test.mjs && node test/multi-gateway.test.mjs"
   },
   "exports": {
     ".": "./lib/index.mjs",