dsh-plugin-mobile-gateway 0.7.1 → 0.7.2

package/PROTOCOL.md

@@ -1,6 +1,6 @@
 # dsh Mobile Gateway — WebSocket 协议参考
 
-移动端通过一个经过设备鉴权的 WebSocket 连接与 dsh 通信：订阅 agent 实时输出、发送文字和图片、处理 Human-in-the-loop 提问与操作审批、查询会话/工作区/历史、调整会话配置。本协议由持久化插件 `dsh-plugin-mobile-gateway` 实现（v0.7.1）。
+移动端通过经过设备鉴权的 WebSocket 连接与 dsh 通信：订阅 agent 实时输出、发送文字和图片、处理 Human-in-the-loop 提问与操作审批、查询会话/工作区/历史、调整会话配置。本协议由持久化插件 `dsh-plugin-mobile-gateway` 实现（v0.7.2）。
 
 - **本机端点**：`ws://127.0.0.1:3080/ws/mobile`（与 dsh web GUI 同端口）
 - **局域网端点**：`ws://<电脑的私有局域网 IP>:3081/ws/mobile`（插件独立监听，只提供经过鉴权的 WebSocket）
@@ -77,7 +77,7 @@ const pairingText = Buffer.from(JSON.stringify(payload), 'utf8').toString('base6
 ```json
 { "kind": "paired", "token": "<长期设备 token>",
   "device": { "id": "...", "name": "iPhone", "createdAt": 1787111700000 } }
-{ "kind": "hello", "protocol": 3, "capabilities": ["images", "commands", "tasks", "goals", "file-downloads"], "authenticated": true,
+{ "kind": "hello", "protocol": 3, "capabilities": ["split-channels", "images", "commands", "tasks", "goals", "session-cancel", "queue-control", "session-archive", "session-rename", "file-downloads"], "authenticated": true,
   "device": { "id": "...", "name": "iPhone" }, "port": 3080, "clients": 1 }
 ```
 
@@ -530,6 +530,73 @@ let image = [
 → { "kind": "sent", "sessionId": "session-abc", "mode": "queue", "command": { "kind": "success", "text": "..." } }   // 斜杠命令时
 ```
 
+### 排队消息同步与修改
+
+`hello.capabilities` 包含 `queue-control` 时，控制连接会收到 Host 当前待处理消息。连接初始化或 Host 控制流重连后，网关发送完整快照：
+
+```json
+{
+  "kind": "session-queues",
+  "queues": {
+    "session-abc": [
+      {
+        "id": "message-1",
+        "placement": "queued",
+        "rpcId": "prompt-1",
+        "message": {
+          "id": "message-1",
+          "content": [{ "type": "text", "text": "稍后处理这件事" }]
+        }
+      }
+    ]
+  }
+}
+```
+
+之后某个 Session 的队列发生变化时，网关发送该 Session 的完整替换值：
+
+```json
+{ "kind": "session-queue", "sessionId": "session-abc", "items": [] }
+```
+
+- `session-queues.queues` 是全量快照，客户端必须整体替换所有 Session 的本地队列；快照里消失的 Session 也要清除。
+- `session-queue.items` 是单个 Session 的全量队列，不能当作追加事件；空数组表示已无待处理消息。
+- `id` 是后续编辑操作使用的 `itemId`。`placement` 为 `queued`（下一回合）、`steering`（当前回合最近的下一步）或 `context`（系统上下文）。
+- `rpcId` 是 Host 的 Prompt 提交标识，网关会原样转发且它可能不存在。当前 `sent` 回执尚未把该值返回给移动端，因此“发送中本地回显与队列项的精确关联”仍是待实现能力。
+
+编辑排队文本：
+
+```json
+{ "type": "queue-update", "sessionId": "session-abc", "itemId": "message-1",
+  "action": "edit", "text": "修改后的消息" }
+→ { "kind": "queue-item-updated", "sessionId": "session-abc", "itemId": "message-1",
+    "action": "edit", "accepted": true }
+```
+
+删除排队项或将下一回合消息立即插入当前回答：
+
+```json
+{ "type": "queue-update", "sessionId": "session-abc", "itemId": "message-1", "action": "remove" }
+{ "type": "queue-update", "sessionId": "session-abc", "itemId": "message-1", "action": "steer" }
+```
+
+`queue-item-updated` 只是 Host 已提交操作的回执，不是队列最终状态。App 应始终以最新的 `session-queue` 更新界面；该推送可能在回执之前或之后到达。编辑只接受非空文本；`steer` 只适用于仍处于 `queued` 且 Session 正在运行的消息。目标已经开始处理或消失时，Host 返回 `session/queue-item-not-found`；当前回合已不能插入时返回 `session/steer-unavailable`。
+
+### 停止当前生成与稍后继续
+
+停止当前 Session 正在执行的 Agent 回合：
+
+```json
+{ "type": "session-cancel", "sessionId": "session-abc" }
+→ { "kind": "session-cancelled", "sessionId": "session-abc", "accepted": true }
+```
+
+- `accepted: true` 表示 Host 已接受取消请求；最终停止状态仍以该 Session 后续实时事件和 `sessions.running` 为准。
+- 取消只停止当前回合，不会删除 Session 历史，也不会清空已经进入 Host inbox 的待处理消息。
+- 稍后继续不需要专用恢复请求。客户端等待 Session 停止后，使用相同 `sessionId` 发送普通 `message` 即可继续已有上下文。
+- 如果 Session 不存在、未附加或属于不能由普通 Session API 控制的子 Agent，服务端返回对应 Host 错误。
+- `session-cancel` 与 `question-cancel` 不同：前者停止整个 Agent 回合，后者只取消一次 `ask_user_question`。
+
 ---
 
 ## 5. 会话与历史查询
@@ -537,6 +604,8 @@ let image = [
 | type | 参数 | 说明 |
 |---|---|---|
 | `sessions` | — | 会话列表（`updatedAt/running/blank/cwd/agentPreset`） |
+| `session-archive` | `sessionId` | 将 Session 加入 Host 的完整归档集合（隐藏但不删除） |
+| `session-rename` | `sessionId`, `title` | 写入用户指定的持久化 Session 名称 |
 | `history` | `sessionId`, `beforeSeq?`, `maxMessages?`, `maxBytes?`, `view?` | 历史事件页（见下） |
 | `attachment` | `sessionId`, `attachmentId` | 读取历史中属于该会话的图片字节 |
 | `file-list` | `sessionId`, `path?`, `requestId?` | 列出会话工作目录内的一层文件与文件夹 |
@@ -549,6 +618,41 @@ let image = [
 | `tasks` | `sessionId` | 当前任务列表（`todos` projection） |
 | `goal` | `sessionId` | 当前目标及其 CAS 版本（`goal` projection） |
 
+### Session 归档与重命名
+
+在 App 端归档 Session：
+
+```json
+{ "type": "session-archive", "sessionId": "session-abc" }
+→ { "kind": "session-archived", "sessionId": "session-abc",
+    "archivedSessionIds": ["session-abc", "session-old"] }
+```
+
+归档仅将 Session 从 Workspace 分组界面隐藏，不会删除历史。`archivedSessionIds` 始终是 Host 确认后的**完整归档集合**，客户端应使用它整体替换本地集合，而不是只追加本次 `sessionId`。
+
+在 App 端重命名 Session：
+
+```json
+{ "type": "session-rename", "sessionId": "session-abc", "title": "新的会话名称" }
+→ { "kind": "session-renamed", "sessionId": "session-abc",
+    "title": "新的会话名称", "seq": 128 }
+```
+
+Host 会规范化并持久化名称；空白名称返回 `bad-request`，超过 Host 限制或规范化后无效的名称返回 Host 的 `session/title-invalid` 错误。
+
+WebUI、App 或其他客户端造成的变化通过以下帧主动推送：
+
+```json
+{ "kind": "session-archives", "archivedSessionIds": ["session-abc"] }
+{ "kind": "session-title-changed", "sessionId": "session-abc",
+  "title": "WebUI 修改后的名称", "seq": 129, "time": 1786937352,
+  "source": { "kind": "user" } }
+```
+
+- `session-archives` 在网关取得 opening baseline 后缓存；新设备连接时会收到当前完整集合，之后每次 WebUI 归档都会收到新的完整集合。
+- `session-title-changed` 是 Session 列表级元数据通知，即使客户端正在 `subscribe` 另一个 Session 也会收到。
+- 同一名称变化仍会作为带序号的普通 `event` 帧发给订阅该 Session 的客户端；客户端可按 `seq` 幂等处理。
+
 ### `history` 详细
 ```json
 { "type": "history", "sessionId": "session-abc", "maxMessages": 60, "maxBytes": 4194304, "view": "conversation" }
@@ -872,8 +976,11 @@ WebUI 中的“任务”与“进行中的目标”分别对应 DSH 的 `todos`
 | kind | 触发时机 |
 |---|---|
 | `paired` | 首次配对成功；仅此一次返回长期设备 token |
-| `hello` | 连接成功：`{ "kind":"hello", "protocol":3, "capabilities":["images","commands","tasks","goals","file-downloads"], "authenticated":true, "port":3080, "clients":1 }` |
+| `hello` | 连接成功：`{ "kind":"hello", "protocol":3, "capabilities":["split-channels","images","commands","tasks","goals","session-cancel","queue-control","session-archive","session-rename","file-downloads"], "authenticated":true, "port":3080, "clients":1 }` |
 | `event` | 任意会话的 agent 输出（见下） |
+| `session-queues` / `session-queue` | Host 队列完整快照 / 单个 Session 队列替换值 |
+| `session-archives` | Host 的完整 Session 归档集合在连接初始化或 WebUI/App 归档后变化 |
+| `session-title-changed` | 任意客户端写入新的持久化 Session 名称 |
 | `tasks-updated` / `goal-updated` | 当前会话的任务列表或目标 projection 发生变化 |
 | `question-requested` / `question-resolved` | Human-in-the-loop 问题请求与最终状态 |
 | `approval-requested` / `approval-resolved` | Human-in-the-loop 操作审批请求与最终状态 |
@@ -888,6 +995,7 @@ WebUI 中的“任务”与“进行中的目标”分别对应 DSH 的 `todos`
 - `user/message` → `{text, source, images?: ImageAttachmentRef[]}`
 - `assistant/chunk` → `{turn, step, chunkType: text-delta|reasoning-delta|tool-call-delta|usage|finish, text?/tool?/usage?/finish?}`
 - `assistant/message` → `{turn, step, text, reasoning, toolCalls[]}`
+- `session/title` → `{title, source?}`
 - `tool/call` → `{turn, step, callId, name, arguments}`
 - `tool/result` → `{turn, step, callId, isError, preview(≤400字符)}`
 - `turn/start|end` / `step/start|end` → `{turn, step, reason?}`
@@ -926,6 +1034,7 @@ WebUI 中的“任务”与“进行中的目标”分别对应 DSH 的 `todos`
 
 | 版本 | 新增 |
 |---|---|
+| v0.7.2 | 独立对话/控制连接；空 Session 创建；停止生成与稍后继续；排队消息同步及编辑/删除/Steer；App 归档/重命名 Session；WebUI 归档集合和名称变化实时同步到 App |
 | v0.1.5 | workspace-create / directories / host |
 | v0.1.6 | 修复消息分发器遗漏（host/directories/workspace-create 未路由） |
 | v0.1.7 | models / select-model / permission-options / permission / context-usage |
@@ -954,3 +1063,37 @@ WebUI 中的“任务”与“进行中的目标”分别对应 DSH 的 `todos`
 ---
 
 *协议与插件源码同源维护：`dsh-plugin-mobile-gateway/lib/index.mjs` 顶部注释即协议摘要。*
+
+### 提前创建空会话
+
+`hello.capabilities` 中的 `session-create` 表示支持发送首条消息前创建会话。
+客户端发送 `{"type":"session-create","requestId":"unique-id","workspaceId":"w1"}`，
+收到 `{"kind":"session-created","requestId":"unique-id","sessionId":"..."}` 后，
+即可使用现有的命令目录、模型和权限接口；该操作不会调用 prompt 或启动 Agent。
+`workspaceId` 与 `cwd` 均可省略，同时提供时优先使用 `workspaceId`。
+失败返回 `kind:error`、`requestType:session-create` 和原始 `requestId`。
+客户端不应自动重试超时的创建请求，以免重复创建会话。
+
+
+### Independent conversation and control connections
+
+A gateway advertising `split-channels` in `hello.capabilities` accepts the optional
+`X-DSH-Channel` upgrade header (`control` or `conversation`). Without this header,
+the connection keeps the legacy behavior. Clients must wait for the control hello
+capability before opening a second connection. Pair only on control; reuse the
+returned device token and device ID for conversation, never reuse a pairing code.
+
+- Conversation: `message`, `history`, `subscribe`, `unsubscribe`; receives their
+  replies and subscribed session events. History and live events share this lane
+  to preserve their ordering.
+- Control: all other requests, including file downloads, rename/archive, session
+  cancellation, permissions, questions and approvals. Global metadata and pending
+  interactions are delivered only to this connection.
+- `ping` is accepted on either connection. A request on the wrong lane receives
+  `error` with code `wrong-channel` and `requestType`.
+
+Each connection has its own WebSocket send queue. A slow conversation receiver
+does not put file responses behind conversation frames. This isolates socket
+queues; the underlying network link and Host resources remain shared. On connection
+failure clients reconnect and authenticate both lanes, then resubscribe and catch up
+history. Older gateways without the capability continue using one connection.

package/README.md

@@ -4,9 +4,9 @@
 
 # dsh-plugin-mobile-gateway
 
-DeepSeek Harness 的设备鉴权移动网关，支持会话与实时事件、任务列表和当前 Goal 同步及管理、服务端驱动的命令和技能菜单、Human-in-the-loop、图片及文件传输。安装后，Harness WebUI 左侧边栏会出现“移动设备”入口，可直接开启网关、生成配对二维码和管理可信设备。
+DeepSeek Harness 的设备鉴权移动网关，支持会话与实时事件、排队消息同步及编辑/删除/Steer、Session 归档和重命名的双向同步、停止当前生成并稍后继续、任务列表和当前 Goal 同步及管理、服务端驱动的命令和技能菜单、Human-in-the-loop、图片及文件传输。安装后，Harness WebUI 左侧边栏会出现“移动设备”入口，可直接开启网关、生成配对二维码和管理可信设备。
 
-> v0.7.1：适配 DSH v0.1.2-rc.1 Remote Gateway，移除 APIProxy 依赖；移动端协议和现有功能保持兼容。
+> v0.7.2：新增独立对话/控制连接、空 Session 创建、停止生成与稍后继续、排队消息同步及编辑/删除/Steer，以及 Session 归档和重命名的双向同步；兼容 DSH v0.1.2-rc.1 与 v0.1.3-alpha.1。
 
 ## 协议与 DSH 兼容层
 

package/docs/typert-remote-gateway-feature-checklist.md

@@ -0,0 +1,296 @@
+# Typert Remote Gateway 功能清单
+
+本文用于持续跟踪 `dsh-plugin-mobile-gateway` 对 DeepSeek Harness 官方 Typert Remote Gateway 能力的适配情况。
+
+- `[x]`：移动网关已经实现，并有对应测试或现有协议文档覆盖。
+- `[ ]`：尚未实现，或当前实现不足以兼容标注的 Host 版本。
+- 对于部分支持的能力，拆成已完成项和待完成子项，不使用含糊的“部分完成”标记。
+- 功能只有在代码、测试和必要协议文档均完成后才能勾选。
+- 每次实现本清单中的功能时，应在同一次变更中更新本文件。
+
+## 版本基线与兼容性
+
+- [x] 支持 DSH `0.1.2-rc.1` 的 Typert Remote 基础契约。
+- [x] 使用独立 Host Adapter 隔离 DSH Remote namespace、method 和严格参数名。
+- [x] 保持移动端 `dsh-mobile-v1`、`hello.protocol = 3` 和现有字段兼容。
+- [ ] 支持 DSH `0.1.3-alpha.1` 的 Typert Remote 契约。
+- [ ] 同时兼容 `0.1.2-rc.1` 与 `0.1.3-alpha.1`，不要求移动端同步升级。
+- [ ] 增加 Host Remote 能力探测并在进程生命周期内缓存探测结果。
+- [ ] 为 `0.1.3-alpha.1` 建立独立的 fake gateway 契约测试。
+- [ ] 建立 RC1 与 Alpha1 双版本回归测试矩阵。
+
+## 连接、鉴权与通用传输
+
+- [x] 提供 `/ws/mobile` WebSocket 入口。
+- [x] 支持本机、独立局域网监听和 TLS 反向代理公网入口。
+- [x] 支持一次性配对码、长期设备 Token 和设备吊销。
+- [x] 局域网监听强制设备鉴权。
+- [x] 支持 `ping` / `pong` 心跳。
+- [x] 支持按 Session 订阅和取消订阅实时事件。
+- [x] 支持统一移动端错误帧。
+- [ ] 为普通 RPC 增加移动端请求 ID 与响应关联。
+- [ ] 支持取消单个正在执行的普通 RPC。
+- [ ] 在移动连接断开时取消该连接拥有的未完成查询、命令和流。
+- [ ] 将 Typert 的结构化错误类别完整映射为稳定的移动端错误码与详情。
+
+## Session 生命周期与查询
+
+- [x] 列出 Session。
+- [x] 搜索 Session 内容。
+- [x] 使用 Workspace 创建 Session。
+- [x] 使用 `cwd` 创建 Session。
+- [x] 创建 Session 后发送第一条消息。
+- [ ] 创建 Session 时显式选择 `agentPreset`。
+- [ ] 创建或采用客户端预分配的 `sessionId`。
+- [x] 在移动端重命名 Session。
+- [x] Fork Session。
+- [x] 支持指定 `atSeq` Fork。
+- [ ] 在 Host 桌面打开 Session Workspace 路径。
+- [x] 查询 Host 是否具备打开 Workspace 路径的能力。
+
+## 消息、队列与运行控制
+
+- [x] 发送文本 Prompt。
+- [x] 发送纯图片 Prompt。
+- [x] 发送图文 Prompt。
+- [x] 支持 `queue` 投递模式。
+- [x] 支持 `steer` 投递模式。
+- [x] 为 Host Prompt 生成唯一 `requestId`。
+- [x] 取消当前正在执行的 Agent 回合，同时保留待处理队列。
+- [x] 取消后使用相同 `sessionId` 发送新消息继续已有会话。
+- [ ] 向移动端返回并持久关联 Prompt `requestId`。
+- [x] 显示 Session 当前排队消息。
+- [x] 编辑一条尚未处理的排队消息。
+- [x] 删除一条尚未处理的排队消息。
+- [x] 将指定排队消息转换为 Steer。
+- [ ] 显示 Session 后台 Job 列表与运行状态。
+
+## 实时会话流与状态同步
+
+- [x] 在 `0.1.2-rc.1` 上通过 Host `session/event` 转发实时 SessionEvent。
+- [x] 转发 `todos` projection 的增量更新。
+- [x] 转发 `goal` projection 的增量更新。
+- [x] 将 WebUI 或其他客户端写入的 `session/title` 变化实时通知移动端。
+- [x] 将 Workspace 归档集合变化实时通知移动端。
+- [ ] 在 `0.1.3-alpha.1` 上使用 `session.follow({ assistantStream: true })` 接收实时 Assistant 流。
+- [ ] 将 `assistant-stream` 的 start/chunk/end 帧转换为现有移动端实时事件。
+- [ ] 处理 Assistant Stream reconnect baseline、revision、index 和 settlement。
+- [ ] 使用 `session.follow` 持续接收 durable event，而不只读取 opening snapshot。
+- [ ] 在断线重连或序号出现缺口时自动补齐 Session 历史。
+- [x] 处理 `session.control` baseline 中的 queues，并在重连时整体替换。
+- [ ] 处理 `session.control` baseline 中的 jobs。
+- [ ] 处理 `session.control` baseline 中除 `todos`、`goal` 外的 projections。
+- [x] 转发 `session.control` 的 queue 更新。
+- [ ] 转发 `session.control` 的 jobs 更新。
+- [ ] 支持除 `todos`、`goal` 之外的通用 projection 更新。
+- [ ] 实时同步 Session 新增事件。
+- [ ] 实时同步 Session 删除事件。
+- [ ] 实时同步 Session running 状态。
+- [ ] 实时同步 Session activity/排序时间。
+- [ ] 实时同步 Session 非持久化错误。
+
+## 历史、统计与附件读取
+
+- [x] 读取 Session opening snapshot。
+- [x] 分页读取更早的历史记录。
+- [x] 展开 RC1 `chunkrow/text-chunks` 历史记录。
+- [x] 展开 RC1 `chunkrow/reasoning-chunks` 历史记录。
+- [x] 展开 RC1 `chunkrow/tool-call-chunks` 历史记录。
+- [x] 支持移动端历史帧字节预算。
+- [x] 支持 conversation 裁剪视图。
+- [x] 读取历史图片附件字节。
+- [x] 查询 Session 统计信息。
+- [x] 查询 Token Usage 与 Context Pressure。
+- [ ] 完整适配 Alpha1 的 Assistant attempt 与 compact stream 历史展示。
+
+## Host 命令与技能
+
+- [x] 按 Session 列出 Host 命令。
+- [x] 执行 `0.1.2-rc.1` Host 命令。
+- [x] 转发 `command/run` 与 `command/done` 生命周期事件。
+- [x] 提供服务端驱动的命令菜单 UI 描述。
+- [x] 提供模型和权限的通用二级选择菜单。
+- [x] 按 Session 列出用户可调用技能。
+- [x] 区分 Model 可调用技能与仅用户技能。
+- [ ] 适配 Alpha1 `commands.execute.submittedAttachments` 参数。
+- [ ] 同时识别 RC1 `input.images` 与 Alpha1 `input.attachments` 命令描述。
+- [ ] 支持向 Host 命令附加普通文件 receipt。
+- [ ] 实时同步 `commands/change`，使移动端命令目录自动刷新。
+
+## Human-in-the-loop
+
+- [x] 转发 `user-questions/request`。
+- [x] 支持单选、多选和自由输入答案。
+- [x] 支持取消整批问题。
+- [x] 校验问题答案的数量、顺序、ID 和选项。
+- [x] 多设备竞争时只接受第一个合法响应。
+- [x] 重放尚未处理的问题。
+- [x] 没有匹配移动连接时回退给 WebUI 或后续 answerer。
+- [x] 转发 `approval/request`。
+- [x] 支持单次允许和拒绝审批。
+- [x] 重放尚未处理的审批。
+- [x] 广播问题和审批的最终状态。
+
+## Workspace 与目录
+
+- [x] 读取 Workspace baseline/list。
+- [x] 创建 Workspace。
+- [x] 使用插件本地文件系统实现浏览 Host 目录。
+- [x] 使用插件本地文件系统创建目录。
+- [ ] 重命名 Workspace。
+- [ ] 删除 Workspace 注册记录。
+- [ ] 调整 Workspace 顺序。
+- [ ] 调整一个 Workspace 内的 Session 顺序。
+- [x] 在移动端归档 Session。
+- [x] 持续消费 `workspace.follow` 的 baseline/archived 更新，并缓存完整归档集合供新连接恢复。
+- [ ] 转发 `workspace.follow` 的 upsert/remove/order 更新。
+- [x] 在 Workspace 流重连时用新 baseline 原子替换缓存的归档集合。
+- [ ] 调用 Host 原生 Directory Picker；此项属于低优先级桌面能力。
+
+## 文件上传、下载与引用
+
+- [x] 上传 Prompt 图片。
+- [x] 下载历史图片附件。
+- [x] 列出 Session Workspace 内的文件和目录。
+- [x] 分块下载 Session Workspace 内的普通文件。
+- [x] 校验文件下载 offset 和最终 SHA-256。
+- [x] 防止通过绝对路径、`..` 或符号链接逃逸 Workspace。
+- [x] 支持取消文件下载并清理空闲传输。
+- [ ] 通过官方 `fileUploads.upload` 上传普通文件。
+- [ ] 支持普通文件的流式 HTTP 上传。
+- [ ] 使用文件 upload receipt 发送 Prompt。
+- [ ] 使用文件 upload receipt 执行 Host 命令。
+- [ ] 支持 `@文件` / `@目录` 候选补全。
+- [ ] 支持跨 Session 引用候选补全。
+- [ ] 支持发送规范化 `dsh-session:` 引用并显示引用快照状态。
+
+## 模型与 Provider
+
+- [x] 获取 Host 模型目录。
+- [x] 获取 Session 当前模型选择。
+- [x] 切换 Session 模型。
+- [x] 切换 Session Reasoning Effort。
+- [x] 读取新 Session 默认模型。
+- [x] 保存新 Session 默认模型。
+- [x] 列出可配置 Provider。
+- [ ] 调用 `llm.listProviders` 获取完整 Provider 运行时信息。
+- [ ] 调用 `llm.discoverModels` 从指定 Provider 配置动态发现模型。
+- [ ] 实时同步 `llm/adapters-updated` 并刷新模型目录。
+
+## 权限与 Settings
+
+- [x] 读取 Settings namespace 描述。
+- [x] 使用 `settings.update` 修改 namespace。
+- [x] 读取权限 Preset 列表。
+- [x] 读取 Session 当前权限。
+- [x] 通过官方 `/permission` 命令切换 Session 权限。
+- [x] 读取和修改新 Session 默认权限。
+- [ ] 使用 `settings.replace` 完整替换 namespace section。
+- [ ] 使用 `settings.mutate` 执行路径级 set/unset 操作。
+- [ ] 完整处理 Settings revision conflict 并返回 Host 最新值。
+- [ ] 实时同步 `settings/document-updated`。
+- [ ] 在 Host 打开 Settings 文档；此项属于低优先级桌面能力。
+- [ ] 在 Host 打开 Agent Preset 目录；此项属于低优先级桌面能力。
+
+## Credentials
+
+- [ ] 查询脱敏后的 Credential 引用状态。
+- [ ] 设置 Credential 值。
+- [ ] 清除 Credential 值。
+- [ ] 实时同步 `credentials/reference-updated`。
+- [ ] 确保任何 Credential Secret 都不会通过移动端查询接口回传。
+
+## Agent Preset
+
+- [x] 列出 Agent Preset 名册。
+- [x] 显示默认 Agent Preset。
+- [x] 修改默认 Agent Preset。
+- [ ] 读取 Preset 文档或插件组成。
+- [ ] 复制可编辑 Preset。
+- [ ] 删除可编辑 Preset。
+- [ ] 为尚未开始的空白 Session 切换 Agent Preset。
+- [ ] 实时同步 `agent-preset/selected`。
+
+## Goal 与任务列表
+
+- [x] 读取 `todos` 任务列表。
+- [x] 实时同步 `todos` 更新。
+- [x] 读取当前 Goal 和 CAS revision。
+- [x] 编辑 Goal objective 或 maxGoalRounds。
+- [x] 暂停 Goal。
+- [x] 恢复 Goal。
+- [x] 清除 Goal。
+- [x] 实时同步 Goal 更新。
+- [ ] 直接创建 Goal。
+- [ ] 将 Goal 标记为完成。
+
+## 子 Agent
+
+- [ ] 列出直接子 Agent 和后代树。
+- [ ] 显示子 Agent 的模式、运行状态和血缘关系。
+- [ ] 向 continuable 子 Agent 发送后续 Prompt。
+- [ ] 在子 Agent 后续 Prompt 中发送图片。
+- [ ] 从父 Session 中断 continuable 子 Agent。
+- [ ] 订阅和展示子 Agent Session 的实时会话流。
+
+## 消息反馈
+
+- [ ] 列出一个 Session 的 Assistant 消息反馈。
+- [ ] 为最终 Assistant 消息添加点赞或点踩。
+- [ ] 为反馈添加备注。
+- [ ] 修改带版本保护的反馈。
+- [ ] 删除带版本保护的反馈。
+- [ ] 处理反馈 version conflict 并向移动端返回当前权威值。
+
+## Host 插件与动态 Cordis
+
+- [ ] 查询 Host 插件清单和运行阶段。
+- [ ] 查询 Agent Preset 的插件组成。
+- [ ] 接收动态 Cordis 包运行请求。
+- [ ] 允许或拒绝包含浏览器半包的动态 Cordis 运行。
+- [ ] 停止或撤销动态 Cordis 包。
+- [ ] 获取动态 Cordis Client 代码。
+- [ ] 同步动态包发布和撤销事件。
+- [ ] 支持 Cordis runtime inspect 查询。
+- [ ] 上报动态 UI 渲染或 Client Guard 失败。
+
+> 动态 Cordis 和 runtime inspect 强依赖 Web 页面生命周期，移动端优先级较低；在明确产品需求前保留未勾选状态。
+
+## 官方 Remote Event 转发
+
+- [x] `approval/request`。
+- [x] `user-questions/request`。
+- [ ] `agent-preset/selected`。
+- [ ] `api-session/activity`。
+- [ ] `api-session/added`。
+- [ ] `api-session/error`。
+- [ ] `api-session/removed`。
+- [ ] `api-session/status`。
+- [ ] `commands/change`。
+- [ ] `credentials/reference-updated`。
+- [ ] `llm/adapters-updated`。
+- [ ] `settings/document-updated`。
+- [ ] `cordis/request-run`。
+- [ ] `cordis/request-run-resolved`。
+- [ ] `cordis/dynamic-package`。
+- [ ] `cordis/dynamic-retract`。
+- [ ] `cordis/inspect-query`。
+- [ ] `cordis/inspect-query-resolved`。
+
+## 暂不纳入正式覆盖率
+
+- [ ] 实验性 Agent Team Remote：`view`、`createTask`、`updateTask`。
+
+> Agent Team 当前没有进入官方标准 `api-remotes` Client Assembly。只有在官方正式挂载或移动端产生明确需求后，才将其移动到正式功能章节。
+
+## 完成定义
+
+勾选一个待实现功能前，至少需要满足以下条件：
+
+- [ ] Host Adapter 已封装对应 Remote 调用或流，不在业务层散落 namespace/method。
+- [ ] 移动端协议请求、响应和错误形态已经定义。
+- [ ] 对应单元测试或网关端到端测试通过。
+- [ ] RC1/Alpha1 相关兼容测试通过，或明确声明该功能只在指定 Host 版本启用。
+- [ ] `PROTOCOL.md` 与 README 中面向用户的能力说明已经同步。
+
+> 本节是每个新功能的验收模板，不表示当前所有待实现功能已经满足这些条件，因此保持未勾选。

package/lib/dsh-host-adapter.mjs

@@ -215,6 +215,9 @@ export function createDshHostAdapter(typertGateway) {
       }), signal),
       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),
+      updateQueue: (payload, signal) => invoke('session', 'updateQueue', requestArgs(payload), signal),
+      rename: (payload, signal) => invoke('session', 'rename', requestArgs(payload), signal),
       selectModel: (payload, signal) => invoke('session', 'selectModel', requestArgs(payload), signal),
       history,
       async models(payload, signal) {
@@ -239,6 +242,7 @@ export function createDshHostAdapter(typertGateway) {
         return requireRecord(frame.value, 'workspace/follow baseline')
       },
       create: (payload, signal) => invoke('workspace', 'create', requestArgs(payload), signal),
+      archiveSession: (payload, signal) => invoke('workspace', 'archiveSession', requestArgs(payload), signal),
     },
     settings: {
       describe: (_payload = {}, signal) => invoke('settings', 'describe', {}, signal),
@@ -300,5 +304,8 @@ export function createDshHostAdapter(typertGateway) {
     openControlStream(signal) {
       return typertGateway.stream({ namespace: 'session', method: 'control', args: {}, signal })
     },
+    openWorkspaceStream(signal) {
+      return typertGateway.stream({ namespace: 'workspace', method: 'follow', args: {}, signal })
+    },
   }
 }

package/lib/index.mjs

@@ -45,6 +45,12 @@
 //                     { "type": "directory-create", "path", "name" } -> create one child directory
 //                     { "type": "workspace-create", "path" }       -> create workspace over a dir
 //                     { "type": "fork", "sessionId", "atSeq"? }    -> branch a new session from a completed turn
+//                     { "type": "session-cancel", "sessionId" }     -> stop the active turn and retain queued work
+//                     { "type": "queue-update", "sessionId", "itemId",
+//                       "action": "edit"|"remove"|"steer", "text"? }
+//                        -> edit/remove one pending item or move it into the current turn
+//                     { "type": "session-archive", "sessionId" }    -> hide a session from workspace surfaces
+//                     { "type": "session-rename", "sessionId", "title" } -> persist a user-owned session title
 //                     { "type": "models", "sessionId"? }           -> per-session catalog (with sessionId) or global (without)
 //                     { "type": "providers" }                       -> configurable provider list (live/dormant)
 //                     { "type": "commands", "sessionId" }          -> slash-command catalog for this session
@@ -68,7 +74,7 @@
 //                     { "type": "question-cancel", "rpcId", "sessionId" }
 //                     { "type": "approval-response", "rpcId", "sessionId", "approvalId",
 //                       "outcome": "allowed-once"|"rejected" }
-//   server -> client: { "kind": "hello", "protocol": 3, "capabilities": ["images", "commands", "tasks", "goals", "file-downloads"],
+//   server -> client: { "kind": "hello", "protocol": 3, "capabilities": ["images", "commands", "tasks", "goals", "session-cancel", "queue-control", "session-archive", "session-rename", "file-downloads"],
 //                       "authenticated", "device"?, "port", "clients" }
 //                     { "kind": "pong", "at" }
 //                     { "kind": "subscribed", "sessionId" }
@@ -88,6 +94,14 @@
 //                       "path", "name", "mediaType", "size", "chunkBytes" }
 //                     { "kind": "file-download-chunk", "transferId", "offset", "data", "eof", "sha256"? }
 //                     { "kind": "file-download-cancelled", "transferId" }
+//                     { "kind": "session-cancelled", "sessionId", "accepted": true }
+//                     { "kind": "queue-item-updated", "sessionId", "itemId", "action", "accepted": true }
+//                     { "kind": "session-queues", "queues": { "<sessionId>": [...] } }
+//                     { "kind": "session-queue", "sessionId", "items": [...] }
+//                     { "kind": "session-archived", "sessionId", "archivedSessionIds" }
+//                     { "kind": "session-renamed", "sessionId", "title", "seq" }
+//                     { "kind": "session-archives", "archivedSessionIds" }
+//                     { "kind": "session-title-changed", "sessionId", "title", "seq", "time", "source"? }
 //                     { "kind": "error", "code", "message", "requestType"?, "sessionId"? }
 //                     { "kind": "event", "sessionId", "seq", "time", "event": { ... } }
 //                     { "kind": "tasks", "sessionId", "asOfSeq", "todos" }
@@ -284,6 +298,14 @@ function buildWireEvent(session, event) {
         event: { type: 'assistant/message', turn: d.turn, step: d.step, text, reasoning, toolCalls, ...(images.length ? { images } : {}) },
       })
     }
+    case 'session/title':
+      return Object.assign(base, {
+        event: {
+          type: 'session/title',
+          title: d.title,
+          ...(d.source ? { source: d.source } : {}),
+        },
+      })
     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 },
@@ -1228,6 +1250,19 @@ async function selectCommandOption(api, host, command, sessionId, optionId) {
 
 // Dispatch one mobile query frame; returns the wire frame to send back.
 async function handleQuery(api, host, agentDefaultModel, msg) {
+  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 = {}
+    if (typeof msg.workspaceId === 'string' && msg.workspaceId.trim()) {
+      payload.workspaceId = msg.workspaceId.trim()
+    } else if (typeof msg.cwd === 'string' && msg.cwd.trim()) {
+      payload.cwd = msg.cwd.trim()
+    }
+    const frame = await proxyQuery(api, 'session-created', api.sessions.create.bind(api.sessions), payload)
+    return { ...frame, ...(frame.kind === 'error' ? { requestType: 'session-create' } : {}), requestId: msg.requestId }
+  }
   if (msg.type === 'workspaces') {
     return proxyQuery(api, 'workspaces', api.workspace.list.bind(api.workspace), {})
   }
@@ -1331,6 +1366,96 @@ async function handleQuery(api, host, agentDefaultModel, msg) {
     }
     return frame
   }
+  if (msg.type === 'session-cancel') {
+    const sessionId = requireSessionId(msg)
+    if (sessionId.error) return sessionId.error
+    const frame = await proxyQuery(
+      api,
+      'session-cancel',
+      api.sessions.cancel.bind(api.sessions),
+      { sessionId: sessionId.value },
+    )
+    if (frame.kind === 'error') return { ...frame, sessionId: sessionId.value }
+    return { ...frame, kind: 'session-cancelled', sessionId: sessionId.value }
+  }
+  if (msg.type === 'queue-update') {
+    const sessionId = requireSessionId(msg)
+    if (sessionId.error) return sessionId.error
+    const itemId = typeof msg.itemId === 'string' && msg.itemId.trim() ? msg.itemId.trim() : null
+    const actionKind = typeof msg.action === 'string' ? msg.action.trim() : ''
+    if (!itemId || !['edit', 'remove', 'steer'].includes(actionKind)) {
+      return {
+        kind: 'error',
+        code: 'bad-request',
+        message: 'queue-update requires itemId and action edit, remove, or steer',
+        requestType: 'queue-update',
+        sessionId: sessionId.value,
+      }
+    }
+    let action
+    if (actionKind === 'edit') {
+      if (typeof msg.text !== 'string' || !msg.text.trim()) {
+        return {
+          kind: 'error',
+          code: 'bad-request',
+          message: 'queue-update edit requires non-empty text',
+          requestType: 'queue-update',
+          sessionId: sessionId.value,
+          itemId,
+        }
+      }
+      action = { kind: 'edit', content: [{ type: 'text', text: msg.text }] }
+    } else {
+      action = { kind: actionKind }
+    }
+    const frame = await proxyQuery(
+      api,
+      'queue-update',
+      api.sessions.updateQueue.bind(api.sessions),
+      { sessionId: sessionId.value, itemId, action },
+    )
+    if (frame.kind === 'error') return { ...frame, sessionId: sessionId.value, itemId }
+    return {
+      ...frame,
+      kind: 'queue-item-updated',
+      sessionId: sessionId.value,
+      itemId,
+      action: actionKind,
+    }
+  }
+  if (msg.type === 'session-archive') {
+    const sessionId = requireSessionId(msg)
+    if (sessionId.error) return sessionId.error
+    const frame = await proxyQuery(
+      api,
+      'session-archive',
+      api.workspace.archiveSession.bind(api.workspace),
+      { sessionId: sessionId.value },
+    )
+    if (frame.kind === 'error') return { ...frame, sessionId: sessionId.value }
+    return { ...frame, kind: 'session-archived', sessionId: sessionId.value }
+  }
+  if (msg.type === 'session-rename') {
+    const sessionId = requireSessionId(msg)
+    if (sessionId.error) return sessionId.error
+    if (typeof msg.title !== 'string' || !msg.title.trim()) {
+      return {
+        kind: 'error',
+        code: 'bad-request',
+        message: 'session-rename requires a non-empty title',
+        requestType: 'session-rename',
+        sessionId: sessionId.value,
+      }
+    }
+    const frame = await proxyQuery(
+      api,
+      'session-rename',
+      api.sessions.rename.bind(api.sessions),
+      { sessionId: sessionId.value, title: msg.title },
+    )
+    if (frame.kind === 'error') return { ...frame, sessionId: sessionId.value }
+    return { ...frame, kind: 'session-renamed', sessionId: sessionId.value }
+  }
   if (msg.type === 'workspace-create') {
     const wsPath = typeof msg.path === 'string' && msg.path.trim() !== '' ? msg.path.trim() : null
     if (!wsPath) {
@@ -1900,7 +2025,9 @@ const plugin = {
         log(`file download expiry failed: ${error && error.message ? error.message : String(error)}`)
       })
     }, Math.min(options.fileDownloadIdleMs, 30_000))
-    const controlStreamAbort = new AbortController()
+    const backgroundStreamAbort = new AbortController()
+    let archivedSessionIds = null
+    let sessionQueues = null
     let counter = 0
     let gatewayEnabled = options.gatewayEnabled === true
     let waitExpiresAt = null
@@ -1984,12 +2111,25 @@ const plugin = {
     const broadcastInteractionFrame = (frame) => {
       const wire = JSON.stringify(frame)
       for (const client of clients) {
+        if (client.mobileChannel === 'conversation') continue
         if (client.filterSessionId && client.filterSessionId !== frame.sessionId) continue
         if (client.readyState === 1) client.send(wire)
       }
     }
 
+    // Session-list metadata must reach every connected client even when it is
+    // subscribed to one conversation. Subscriptions only scope the heavier
+    // conversation and interaction streams.
+    const broadcastSessionMetadataFrame = (frame) => {
+      const wire = JSON.stringify(frame)
+      for (const client of clients) {
+        if (client.mobileChannel === 'conversation') continue
+        if (client.readyState === 1) client.send(wire)
+      }
+    }
+
     const replayPendingInteractions = (ws, trigger) => {
+      if (ws.mobileChannel === 'conversation') return { questionCount: 0, approvalCount: 0 }
       let questionCount = 0
       let approvalCount = 0
       for (const pending of pendingQuestions.values()) {
@@ -2008,6 +2148,7 @@ const plugin = {
 
     const hasInteractionClient = (sessionId) => [...clients].some((client) => (
       client.readyState === 1
+      && client.mobileChannel !== 'conversation'
       && (!client.filterSessionId || client.filterSessionId === sessionId)
     ))
 
@@ -2337,6 +2478,8 @@ const plugin = {
         wss.handleUpgrade(req, socket, head, (ws) => {
           const id = ++counter
           ws.filterSessionId = undefined
+          const requestedChannel = req.headers['x-dsh-channel']
+          ws.mobileChannel = ['control', 'conversation'].includes(requestedChannel) ? requestedChannel : 'legacy'
           ws.deviceId = device && device.id
           clients.add(ws)
           if (device) registry.connected(device.id)
@@ -2357,6 +2500,12 @@ const plugin = {
               return
             }
             if (!msg || typeof msg.type !== 'string') return
+            const conversationRequest = ['message', 'history', 'subscribe', 'unsubscribe'].includes(msg.type)
+            if ((ws.mobileChannel === 'control' && conversationRequest) ||
+                (ws.mobileChannel === 'conversation' && !conversationRequest && msg.type !== 'ping')) {
+              ws.send(JSON.stringify({ kind: 'error', code: 'wrong-channel', requestType: msg.type, message: 'Request belongs to the other mobile channel' }))
+              return
+            }
 
             if (msg.type === 'ping') {
               ws.send(JSON.stringify({ kind: 'pong', at: Date.now() }))
@@ -2386,12 +2535,13 @@ const plugin = {
               })
             } else if (msg.type === 'workspaces' || msg.type === 'sessions' || msg.type === 'history' || msg.type === 'attachment' ||
                        msg.type === 'search' || msg.type === 'host' || msg.type === 'directories' || msg.type === 'directory-create' ||
-                       msg.type === 'workspace-create' || msg.type === 'models' || msg.type === 'commands' || msg.type === 'command-execute' ||
+                       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 === 'session-stats' || msg.type === 'default-model' ||
-                       msg.type === 'save-default-model' || msg.type === 'fork' || msg.type === 'providers' ||
+                       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' ||
                        msg.type === 'tasks' || msg.type === 'goal' || msg.type === 'goal-edit' ||
                        msg.type === 'goal-pause' || msg.type === 'goal-resume' || msg.type === 'goal-clear') {
               handleQuery(api, host, agentDefaultModel, msg).then((frame) => {
@@ -2423,12 +2573,30 @@ const plugin = {
           ws.send(JSON.stringify({
             kind: 'hello',
             protocol: 3,
-            capabilities: ['images', 'commands', 'tasks', 'goals', ...(options.fileDownloadsEnabled ? ['file-downloads'] : [])],
+            capabilities: [
+              'split-channels',
+              'images',
+              'session-create',
+              'commands',
+              'tasks',
+              'goals',
+              'session-cancel',
+              'queue-control',
+              'session-archive',
+              'session-rename',
+              ...(options.fileDownloadsEnabled ? ['file-downloads'] : []),
+            ],
             port: transport.port || webServer.port,
             clients: clients.size,
             authenticated: !!device,
             ...(device ? { device: { id: device.id, name: device.name } } : {}),
           }))
+          if (ws.mobileChannel !== 'conversation' && archivedSessionIds !== null) {
+            ws.send(JSON.stringify({ kind: 'session-archives', archivedSessionIds }))
+          }
+          if (ws.mobileChannel !== 'conversation' && sessionQueues !== null) {
+            ws.send(JSON.stringify({ kind: 'session-queues', queues: Object.fromEntries(sessionQueues) }))
+          }
           replayPendingInteractions(ws, 'connect')
         })
     }
@@ -2486,8 +2654,19 @@ const plugin = {
       if (clients.size === 0) return
       const wire = buildWireEvent(session, event)
       if (!wire) return
+      if (event.type === 'session/title' && typeof event.data?.title === 'string') {
+        broadcastSessionMetadataFrame({
+          kind: 'session-title-changed',
+          sessionId: String(session.id),
+          title: event.data.title,
+          seq: event.seq,
+          time: event.time,
+          ...(event.data.source ? { source: event.data.source } : {}),
+        })
+      }
       const payload = JSON.stringify(wire)
       for (const client of clients) {
+        if (client.mobileChannel === 'control') continue
         if (client.filterSessionId && client.filterSessionId !== String(session.id)) continue
         if (client.readyState === 1) client.send(payload)
       }
@@ -2548,50 +2727,138 @@ const plugin = {
       })
     }, { prepend: true })
 
-    const projectionTask = (async () => {
-      while (!controlStreamAbort.signal.aborted) {
+    const waitForBackgroundRetry = () => new Promise((resolve) => {
+      if (backgroundStreamAbort.signal.aborted) {
+        resolve()
+        return
+      }
+      const finish = () => {
+        clearTimeout(timer)
+        backgroundStreamAbort.signal.removeEventListener('abort', finish)
+        resolve()
+      }
+      const timer = setTimeout(finish, 1_000)
+      backgroundStreamAbort.signal.addEventListener('abort', finish, { once: true })
+    })
+
+    const installArchivedSessionIds = (value) => {
+      if (!Array.isArray(value)) throw new Error('workspace/follow returned invalid archivedSessionIds')
+      const next = value.map((sessionId) => String(sessionId))
+      if (archivedSessionIds !== null
+        && archivedSessionIds.length === next.length
+        && archivedSessionIds.every((sessionId, index) => sessionId === next[index])) return
+      archivedSessionIds = next
+      broadcastSessionMetadataFrame({ kind: 'session-archives', archivedSessionIds: next })
+      log(`session archive state forwarded: count=${next.length}`)
+    }
+
+    const normalizeQueueItems = (value, endpoint) => {
+      if (!Array.isArray(value)) throw new Error(`${endpoint} returned invalid queue items`)
+      return value.map((candidate) => {
+        const message = candidate && typeof candidate === 'object' && !Array.isArray(candidate)
+          ? candidate.message
+          : null
+        if (!candidate || typeof candidate !== 'object' || Array.isArray(candidate)
+          || typeof candidate.id !== 'string' || !candidate.id
+          || !['queued', 'steering', 'context'].includes(candidate.placement)
+          || !message || typeof message !== 'object' || Array.isArray(message)
+          || typeof message.id !== 'string' || !message.id
+          || !Array.isArray(message.content)
+          || (candidate.rpcId !== undefined && typeof candidate.rpcId !== 'string')) {
+          throw new Error(`${endpoint} returned an invalid queue item`)
+        }
+        return {
+          id: candidate.id,
+          placement: candidate.placement,
+          ...(candidate.rpcId === undefined ? {} : { rpcId: candidate.rpcId }),
+          message: { id: message.id, content: message.content },
+        }
+      })
+    }
+
+    const installSessionQueueBaseline = (value) => {
+      if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new Error('session/control baseline returned invalid queues')
+      }
+      const next = new Map()
+      for (const [sessionId, items] of Object.entries(value)) {
+        next.set(sessionId, normalizeQueueItems(items, 'session/control baseline'))
+      }
+      sessionQueues = next
+      broadcastSessionMetadataFrame({ kind: 'session-queues', queues: Object.fromEntries(next) })
+      log(`session queue baseline forwarded: sessions=${next.size}`)
+    }
+
+    const installSessionQueue = (sessionIdValue, itemsValue) => {
+      const sessionId = typeof sessionIdValue === 'string' && sessionIdValue ? sessionIdValue : null
+      if (!sessionId) throw new Error('session/control returned an invalid queue sessionId')
+      const items = normalizeQueueItems(itemsValue, 'session/control queue')
+      if (sessionQueues === null) sessionQueues = new Map()
+      sessionQueues.set(sessionId, items)
+      broadcastSessionMetadataFrame({ kind: 'session-queue', sessionId, items })
+      log(`session queue forwarded: session=${sessionId} items=${items.length}`)
+    }
+
+    const workspaceTask = (async () => {
+      while (!backgroundStreamAbort.signal.aborted) {
         try {
-          const stream = await api.openControlStream(controlStreamAbort.signal)
+          const stream = await api.openWorkspaceStream(backgroundStreamAbort.signal)
           for await (const frame of stream) {
-            if (frame?.type !== 'projection' || (frame.key !== 'todos' && frame.key !== 'goal')) continue
-            const sessionId = String(frame.sessionId)
-            const kind = frame.key === 'todos' ? 'tasks-updated' : 'goal-updated'
-            const valueKey = frame.key === 'todos' ? 'todos' : 'goal'
-            broadcastInteractionFrame({
-              kind,
-              sessionId,
-              asOfSeq: frame.seq,
-              [valueKey]: frame.value,
-            })
-            log(`projection forwarded: key=${frame.key} session=${sessionId} seq=${frame.seq}`)
+            if (frame?.type === 'baseline') {
+              installArchivedSessionIds(frame.value?.archivedSessionIds)
+            } else if (frame?.type === 'archived') {
+              installArchivedSessionIds(frame.archivedSessionIds)
+            }
           }
-          if (!controlStreamAbort.signal.aborted) log('session control stream ended; retrying')
+          if (!backgroundStreamAbort.signal.aborted) log('workspace stream ended; retrying')
         } catch (error) {
-          if (!controlStreamAbort.signal.aborted) {
-            log(`session control stream failed; retrying: ${error && error.message ? error.message : String(error)}`)
+          if (!backgroundStreamAbort.signal.aborted) {
+            log(`workspace stream failed; retrying: ${error && error.message ? error.message : String(error)}`)
           }
         }
-        if (controlStreamAbort.signal.aborted) break
-        await new Promise((resolve) => {
-          const onAbort = () => {
-            clearTimeout(timer)
-            resolve()
+        if (!backgroundStreamAbort.signal.aborted) await waitForBackgroundRetry()
+      }
+    })()
+    void workspaceTask
+
+    const controlTask = (async () => {
+      while (!backgroundStreamAbort.signal.aborted) {
+        try {
+          const stream = await api.openControlStream(backgroundStreamAbort.signal)
+          for await (const frame of stream) {
+            if (frame?.type === 'baseline') {
+              installSessionQueueBaseline(frame.value?.queues)
+            } else if (frame?.type === 'queue') {
+              installSessionQueue(frame.sessionId, frame.items)
+            } else if (frame?.type === 'projection' && (frame.key === 'todos' || frame.key === 'goal')) {
+              const sessionId = String(frame.sessionId)
+              const kind = frame.key === 'todos' ? 'tasks-updated' : 'goal-updated'
+              const valueKey = frame.key === 'todos' ? 'todos' : 'goal'
+              broadcastInteractionFrame({
+                kind,
+                sessionId,
+                asOfSeq: frame.seq,
+                [valueKey]: frame.value,
+              })
+              log(`projection forwarded: key=${frame.key} session=${sessionId} seq=${frame.seq}`)
+            }
           }
-          const timer = setTimeout(() => {
-            controlStreamAbort.signal.removeEventListener('abort', onAbort)
-            resolve()
-          }, 1_000)
-          controlStreamAbort.signal.addEventListener('abort', onAbort, { once: true })
-        })
+          if (!backgroundStreamAbort.signal.aborted) log('session control stream ended; retrying')
+        } catch (error) {
+          if (!backgroundStreamAbort.signal.aborted) {
+            log(`session control stream failed; retrying: ${error && error.message ? error.message : String(error)}`)
+          }
+        }
+        if (!backgroundStreamAbort.signal.aborted) await waitForBackgroundRetry()
       }
     })()
-    void projectionTask
-    log('Host waterfall interaction listeners and session control stream attached')
+    void controlTask
+    log('Host waterfall interaction listeners, workspace stream, and session control stream attached')
 
     ctx.effect(() => () => {
       if (waitTimer) clearTimeout(waitTimer)
       clearInterval(fileTransferExpiryTimer)
-      controlStreamAbort.abort()
+      backgroundStreamAbort.abort()
       for (const pending of [...pendingQuestions.values()]) fallbackQuestion(pending)
       for (const pending of [...pendingApprovals.values()]) fallbackApproval(pending)
       fileTransfers.dispose().catch((error) => {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-plugin-mobile-gateway",
-  "version": "0.7.1",
-  "description": "Secure mobile gateway for DeepSeek Harness with realtime sessions, tasks, goals, commands, approvals, and file transfers",
+  "version": "0.7.2",
+  "description": "Secure mobile gateway for DeepSeek Harness with split realtime/control channels, editable queues, stop/resume, archive/rename sync, tasks, goals, commands, approvals, and file transfers",
   "main": "lib/index.mjs",
   "files": [
     "bin",